m (Reverting vandalism)
Tag: Source edit
Line 1: Line 1:
  +
 
'''Infra notation''' is a notation for large numbers made by Wikia user [[User:Nirvana Supermind|Nirvana Supermind]].<ref>{{cite web|last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/infra-notation/|title=Infra Notation - Integral View}}</ref>.
 
'''Infra notation''' is a notation for large numbers made by Wikia user [[User:Nirvana Supermind|Nirvana Supermind]].<ref>{{cite web|last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/infra-notation/|title=Infra Notation - Integral View}}</ref>.
   
 
The notation is currently composed of 1 parts, which is as follows:
 
The notation is currently composed of 1 parts, which is as follows:
   
* [https://integralview.wordpress.com/2020/12/08/basic-infra-notation/ Basic Infra Notation] (BIN)<ref>{{cite web||last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/basic-infra-notation/|title=Basic Infra Notation - Integral View (retrieved at UTC 10:00 09/12/2020)}} </ref>.
+
* [https://integralview.wordpress.com/2020/12/08/basic-infra-notation/ Basic Infra Notation] (BIN)<ref name="first">{{cite web||last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/basic-infra-notation/|title=Basic Infra Notation - Integral View|accessdate=Wed, 09 Dec 2020 10:34:00 GMT}}</ref><ref name="latest">{{cite web||last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/basic-infra-notation/|title=Basic Infra Notation - Integral View|accessdate=Wed, 09 Dec 2020 23:47:08 GMT}</ref>.
  +
   
Whenever the creator makes a new notation, they say "it is composed of <number> parts", even if they do not intend to 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 notation ==
  +
=== Current version ===
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.
 
  +
All information here only applies to the latest version of the notation.
   
  +
Basic Infra Notation (BIN) is the 1st part of Infra Notation.<ref name="latest" /> 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
=== 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:
 
   
 
# I<> = 0
 
# I<> = 0
 
# I<a> = 10<sup>a</sup>
 
# I<a> = 10<sup>a</sup>
# I<#,0> = I<#>
+
# I<#,1> = I<#>
 
# I<a,b> = I&lt;I&lt;...&lt;I<a,b-1&gt;,b-1&gt;,...&gt;,b-1&gt; (b>0) for a times
 
# I<a,b> = I&lt;I&lt;...&lt;I<a,b-1&gt;,b-1&gt;,...&gt;,b-1&gt; (b>0) for a times
   
Where # is a part of said array (a string of entries and commas, it can also be empty). If 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_{\omega}(n)\) in the [[Fast-growing hierarchy]].
+
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 <math>f<sub>ω</sub>(n)</math> in the [[Fast-growing hierarchy]].
   
Note that 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. Indeed, none of them was well-defined when the creator created the corresponding article in this wiki.
 
   
 
==== Example ====
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 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<>,<ref name="removement 1">[https://googology.wikia.org/wiki/Infra_Notation?type=revision&diff=307183&oldid=307182 A difference page] of this article. (The creator removed the description of the issue and the alternative definition by saying ""Your explanation is incorrect. The empty string is valid expression, it is stated that the array can be I<>. And that expression is also not ill-defined, since I had the foresight to put "I<> = 0"."".)</ref> but they skip over how it is derived. After applying rule 4, it becomes I&lt;I&lt;...&lt;I<0,0&gt;,0&gt;,...&gt;,0> for 0 times. This does not make sense.
 
  +
I&lt;3,1&gt;
   
 
= I&lt;I&lt;...&lt;I<3,0&gt;,0&gt;,...&gt;,0&gt; for 3 times
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'''.
 
<ref name="typo 1">[https://googology.wikia.org/wiki/Talk:Quick_array_notation?type=revision&diff=303924&oldid=303906 A difference page] of the talk page of another article. (The creator said "What is the point of saying a notation is ill-defined because there was a typo or two from my XS-based draft?".)</ref>
 
<ref name="typo 2">[https://googology.wikia.org/wiki/Talk:Quick_array_notation?type=revision&diff=303943&oldid=303930 A difference page] of the talk page of another article. (The creator said ""The reason you say "Since there are common errors in the original version and other versions, we start with the explanation of the original version first." is a false because the current notation '''is well-defined'''"" and "'''all mistakes you mentioned are typos, errors and mistakes I made, that do not contribute to the well-definedness or ill-definedness of a notation.'''")</ref>
 
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<>.
 
   
 
= I&lt;I&lt;I&lt;3,0&gt;,0&gt;,0&gt;
=== Example ===
 
I<3,1>
 
   
= I<I<...&lt;I<3,0&gt;,0&gt;,...&gt;,0&gt; for 3 times
+
= I&lt;I&lt;&lt;I<3&gt;&gt;&gt;
 
= I<I<I<3,0&gt;,0&gt;,0&gt;
 
 
= I<I<I<3&gt;&gt;&gt;
 
   
 
= 10<sup>10<sup>1000</sup></sup>
 
= 10<sup>10<sup>1000</sup></sup>
   
I<0,1> = ill-defined (According to the creator, it expands as I<>.<ref name="removement 1"/>)
 
 
=== 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:
 
# If @ is the empty string, then I<@> = 0.
 
# If @ = "a" for a non-negative integer a, then I<@> = 10<sup>a</sup>.
 
# If @ = "#,0" for a non-empty array # of non-negative integers, then I<@> = I<#>.
 
# If @ = "#,a,b" for an array # of non-negative integers, non-negative integer a, and a positive integer b, then I<@> = I<sup>a</sup><#,a,b-1>, where I<sup>n</sup><#,a,b-1> is the non-negative integer defined for any non-negative integer n in the following recursive way:
 
## If n = 0, then I<sup>n</sup><#,a,b-1> = a.
 
## If n ≠ 0, then I<sup>n</sup><#,a,b-1> = I<#,I<sup>n-1</sup><#,a,b-1>,b-1>.
 
For example, we have I<0,1> = I<sup>0</sup><0,0> = 0. Fortunately, this result coincides with the creator's intension I<0,1> = I<> = 0. Therefore the restriction of this alternative defition 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.
 
   
== See also ==
+
=== Old version ===
  +
An old version of the notation had the input be an array of nonnegative integers instead<ref name="first" />. It also had the rule "I<#,0> = I<#>" instead of the current third rule. 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.
* [[Rampant Array Notation]]
 
* [[Extensible Illion System]]
 
* [[Quick array notation]]
 
   
  +
However, the creator fixed those issues.
  +
==== Example ====
  +
I<0,1> = ill-defined
 
== Sources ==
 
== Sources ==
 
<references />
 
<references />
[[Category:Numbers by Nirvana Supermind]]
 
 
[[Category:Notations]]
 
[[Category:Notations]]
 
[[Category:Functions]]
 
[[Category:Functions]]
[[Category:Incomplete]]
 

Revision as of 00:13, 10 December 2020

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) 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. The creator said that this notation most likely reaches Failed to parse (syntax error): {\displaystyle f<sub>ω</sub>(n)} in the Fast-growing hierarchy.


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

= 10101000


Old version

An old version of the notation had the input be an array of nonnegative integers instead[2]. It also had the rule "I<#,0> = I<#>" instead of the current third rule. 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.

Example

I<0,1> = ill-defined

Sources

  1. Nirvana Supermind. Infra Notation - Integral View
  2. 2.0 2.1 Nirvana Supermind. Basic Infra Notation - Integral View. Retrieved Wed, 09 Dec 2020 10:34:00 GMT.
  3. 3.0 3.1 {{cite web||last=Nirvana Supermind|url=https://integralview.wordpress.com/2020/12/08/basic-infra-notation/%7Ctitle=Basic Infra Notation - Integral View|accessdate=Wed, 09 Dec 2020 23:47:08 GMT}
Community content is available under CC-BY-SA unless otherwise noted.