10,964 Pages

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

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

## Basic notation

### Current version

All information here only applies to the latest version of the notation.

Basic Infra Notation (BIN) is the 1st part of Infra Notation.[3] An array is of the form I<>, I<a>, or I<a,b>. The numbers inside the angle brackets are called entries. All numbers in the array must be positive integers. It’s the simplest and weakest one. The rules for it are

1. I<> = 0
2. I<a> = 10a
3. I<#,1> = I<#>
4. I<a,b> = I<I<...<I<a,b-1>,b-1>,...>,b-1> (b>0) with "a" nestings

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. The creator said that this notation most likely reaches in the Fast-growing hierarchy.

#### Example

I<3,2>

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

= I<I<I<3,1>,1,1>

= I<I<I<3>>>

= 10^10^1000

### Old version

All information here only applies to the oldest version of the notation.

An old version of the notation had an input of a nonnegative integer array[2]. It also had the rule "I<#,0> = I<#>" instead of the current third rule, and a less precise description of "with a nestings". 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.

However, the creator fixed those issues by changing the input to a positive integer array in the current version.

#### Example

I<0,1> = ill-defined

### P進大好きbot's definition

When the issues with the notation had not been fixed, user P進大好きbot created an alternate definition of this notation that is well-defined. 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<@> = 10a.
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<@> = Ia<#,a,b-1>, where In<#,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 In<#,a,b-1> = a.
2. If n ≠ 0, then In<#,a,b-1> = I<#,In-1<#,a,b-1>,b-1>.

For example, we have I<0,1> = I0<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.

P進大好きbot's definition is identical to the Original version, except it defines "for b times" using an iterative method that will work for 0.

## Sources

1. Nirvana Supermind. Infra Notation - Integral View
2. Nirvana Supermind. Basic Infra Notation - Integral View. Retrieved Wed, 09 Dec 2020 10:34:00 GMT.
3. Nirvana Supermind. Basic Infra Notation - Integral View. Retrieved Thu, 10 Dec 2020 02:40:00 GMT.
Community content is available under CC-BY-SA unless otherwise noted.