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).

It is notable that the creator always insists that something like "The notation is currently composed of 1 parts" whenever he or she started to make a new notation, it does not mean that he or she will expand it. Indeed, the creator invented Rampant Array Notation, Extensible Illion System, and Quick array notation, but none of them has been completed.

Basic notation

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

Original 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. 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. The creator said that this notation most likely reaches f_ω(n) in the Fast-growing hierarchy.

Note that the creator always insists something like "this notation is well-defined" or "this notation most likely reaches blah-blah", but those statements are not necessarily true. Indeed, none of them was well-defined when the creator created the corresponding article in this wiki. Unfortunately, this notation is not a counterexample, as 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 resulting expression is the empty string, which is not a valid expression, or some unspecified expression, as the description "for 0 times" itself is ambiguous. Namely, this notation is ill-defined, if we consider the issue. 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.

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

Alternative 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.

See also

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