m (Undo revision 303900 by Nirvana Supermind (talk) Rverting the removement of the ill-definedness. As the article clearly explains, it is currently ill-defined.) Tag: Undo |
CompactStar (talk | contribs) No edit summary Tag: Source edit |
||
| (7 intermediate revisions by the same user not shown) | |||
| Line 1: | Line 1: | ||
| − | '''Quick array notation''' is a notation for large numbers made by Wikia user [[User:Nirvana Supermind|Nirvana Supermind]]<ref>[https://integralview.wordpress.com/2020/11/15/nimble-array-notation/ Quick array notation] (Retrieved at (UTC) |
+ | '''Quick array notation''' is a notation for large numbers made by Wikia user [[User:Nirvana Supermind|Nirvana Supermind]]<ref>[https://integralview.wordpress.com/2020/11/15/nimble-array-notation/ Quick array notation] (Retrieved at (UTC) 6:30 22/11/2020)</ref>. The notation is currently composed of 1 extension |
, which is as follows: |
, which is as follows: |
||
| − | * Linear array notation<ref name=" |
+ | * Linear array notation<ref name="newest">[https://integralview.wordpress.com/2020/11/15/linear-array-notation/ Linear array notation] (Retrieved at UTC 6:30 22/11/2020)</ref><ref name="first">[https://integralview.wordpress.com/2020/11/15/linear-array-notation/ Linear array notation] (Retrieved at (UTC) 10:30 20/11/2020)</ref> |
| − | |||
| − | Unfortunately , it is ill-defined, as is explained later. |
||
== Linear array notation == |
== Linear array notation == |
||
'''Linear array notation''' is the first part of quick array notation. |
'''Linear array notation''' is the first part of quick array notation. |
||
| − | === |
+ | === Current version === |
| − | + | All information here only applies to the current version of the notation, which is given after the issues on the original definition were pointed out. |
|
==== Definition ==== |
==== Definition ==== |
||
| ⚫ | |||
| ⚫ | |||
| + | |||
| ⚫ | |||
| + | |||
| + | The rules for it are: |
||
# Q<> = Q<a> = 0 |
# Q<> = Q<a> = 0 |
||
# Q<a,b> = a*b |
# Q<a,b> = a*b |
||
| − | # Q<#,0> = |
+ | # Q<#,0> = Q<#> |
# Q<a,1,#> = a for b>0 |
# Q<a,1,#> = a for b>0 |
||
| − | # Q<a,b,c,#> = |
+ | # Q<a,b,c,#> = Q<a,Q<a,b-1,c,#>,c-1,#> for b>0 |
| − | Here # denotes a portion of the array, which can be empty |
+ | Here # denotes a portion of the array, which can 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. If none of the 3 rules above applies, start the process shown below starting from the third entry inside the brackets: |
| − | + | * Case A: If the entry is 0, jump to the next entry. |
|
| − | |||
| ⚫ | |||
* Case B: If the entry is not 0, then: |
* Case B: If the entry is not 0, then: |
||
** Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array. |
** Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array. |
||
| Line 33: | Line 33: | ||
** Terminate the process. Repeat if the rules still do not apply. |
** Terminate the process. Repeat if the rules still do not apply. |
||
| − | + | The creator stated that this extension most likely reaches ω<sup>ω</sup> in the [[fast-growing hierarchy]]. |
|
| ⚫ | |||
| ⚫ | |||
| ⚫ | Let us compute Q<0,0,0>. The resulting expression is x<0,0> for some x, because the third rule is applicable. Since there is no rule applicable to x<0,0>, we need to start the exceptional process. In Case A, the process refers to "it". Since the terminology of "it" is quite ambiguous, there are two possibilities: |
||
| ⚫ | |||
| ⚫ | |||
| ⚫ | In the first interpretation, there is no clarification of what entry the process refers to first. Perhaps it should be the first entry of the array following the outer iterator x. Since the first entry is 0, Case A is applicable. Then the current entry becomes the next 0, and hence Case A is applicable again. However, there is no entry next to the current entry, and hence the process does not terminate in a usual way. |
||
| ⚫ | |||
| ⚫ | In the second interpretation, then Case A does not change it. Therefore the process for x<0,0> causes an infinite loop if the undefined x is 0. In any case, the reference to the undefined value x is invalid. As a result, x<0,0> and hence Q<0,0,0> are ill-defined. In particular, the analysis by the creator is wrong. |
||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| − | ==== Examples ==== |
||
| ⚫ | |||
| − | Q<0,0,0> = x<0,0> (ill-defined) |
||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| − | Next, we explain the current version, which is given after the issues on the original definition were pointed out.<ref name="newest">[https://integralview.wordpress.com/2020/11/15/linear-array-notation/ Linear array notation] (Retrieved at (UTC) 12:00 21/11/2020)</ref> |
||
| + | |||
| + | === Original version === |
||
| + | All information here only applies to the old version of the notation. |
||
| ⚫ | An old version of the notation had |
||
==== Definition ==== |
==== Definition ==== |
||
| ⚫ | |||
| ⚫ | |||
| − | |||
| ⚫ | |||
| − | |||
| − | The domain is perhaps intended to be the set of all arrays of non-negative integers, although the current definition<ref name="newest" /> has the same typo "Where are nonnegative integers" of "Where a, b, c, and so on are nonnegative integers" or something like that as the original definition<ref name="first" /> explained above. The rules for it are: |
||
# Q<> = Q<a> = 0 |
# Q<> = Q<a> = 0 |
||
# Q<a,b> = a*b |
# Q<a,b> = a*b |
||
| − | # Q<#,0> = |
+ | # Q<#,0> = x<#> |
# Q<a,1,#> = a for b>0 |
# Q<a,1,#> = a for b>0 |
||
| − | # Q<a,b,c,#> = |
+ | # Q<a,b,c,#> = x<a,x<a,b-1,c,#>,c-1,#> for b>0 |
| − | Here # denotes a portion of the array, which can 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. |
+ | Here # denotes a portion of the array, which can be empty, and x denotes some number. In the original source, it is written "the outer number x is called the iterator, and it". 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. |
| − | + | If none of the 3 rules above applies, start the process shown below: |
|
| + | |||
| ⚫ | |||
* Case B: If the entry is not 0, then: |
* Case B: If the entry is not 0, then: |
||
** Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array. |
** Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array. |
||
| Line 77: | Line 75: | ||
** Terminate the process. Repeat if the rules still do not apply. |
** Terminate the process. Repeat if the rules still do not apply. |
||
| + | This notation is intended to reach ω<sup>ω</sup> in the fast-growing hierarchy by the creator, but is ill-defined mainly because x, which is called "it", is undefined. |
||
| − | The entry to which the exceptional process refers first is not clear, similarly to the original version<ref name="first" /> explained above. Even if we fix the entry in a reasonable way, it is still ill-defined. See "Issues" section below for the detail. |
||
| − | |||
| − | ==== Issues ==== |
||
| − | |||
| − | Since it is written "In other words, from the 3rd entry on, we search for the first non-0 entry." right after the description of the exceptional process in the current source, there are two possibilities: |
||
| − | # Following the explanation in the current definition, the entry to which the process refers first is the third entry. |
||
| − | # Ignoring the explanation in the current definition, the entry to which the process refers first is the first entry. |
||
| − | If we assume the first possibility, consider Q<0,2,1>. Then the entry to which the process refers first is the third entry 1, and hence Case B is applied to it. However, the pair of the previous entry and the current entry is 2,1, which is not of the form 0,n, where n is the current entry 1. Therefore Case B does not make sense. As a reuslt, Q<0,2,1> is ill-defined in that case. |
||
| − | |||
| − | If we assume the second possibility, consider Q<1,2,1>. Then the entry to which the process refers first is the first entry 1, and hence Case B is applied to it. However, there is no previous entry, while the rule refers to it as 0 in order to replace it to the seoncd entry b = 2. Therefore Case B does not make sense. As a reuslt, Q<1,2,1> is ill-defined in that case. |
||
| − | |||
| − | As a conclusion, the current version is ill-defined, too. |
||
==== Example ==== |
==== Example ==== |
||
| ⚫ | Let us compute Q<0,0,0>. The resulting expression is x<0,0> for some x, because the third rule is applicable. Since there is no rule applicable to x<0,0>, we need to start the exceptional process. In Case A, the process refers to "it". Since the terminology of "it" is quite ambiguous, there are two possibilities: |
||
| ⚫ | |||
| ⚫ | |||
| ⚫ | |||
| ⚫ | In the first interpretation, there is no clarification of what entry the process refers to first. Perhaps it should be the first entry of the array following the outer iterator x. Since the first entry is 0, Case A is applicable. Then the current entry becomes the next 0, and hence Case A is applicable again. However, there is no entry next to the current entry, and hence the process does not terminate in a usual way. |
||
| ⚫ | In the second interpretation, then Case A does not change it. Therefore the process for x<0,0> causes an infinite loop if the undefined x is 0. In any case, the reference to the undefined value x is invalid. As a result, x<0,0> and hence Q<0,0,0> are ill-defined. In particular, the analysis by the creator is wrong. |
||
| ⚫ | |||
| − | |||
| ⚫ | |||
| − | |||
| ⚫ | |||
| − | |||
| ⚫ | |||
| − | |||
| ⚫ | |||
| ⚫ | |||
| − | Either Q<0,2,1> or Q<1,2,1> is ill-defined, depending on the interpretaions of the entry to which the exceptional process refers first. |
||
| + | There is also a second old version of this notaion in an attempt to fix it.<ref name="second">[https://integralview.wordpress.com/2020/11/15/linear-array-notation/ Linear array notation] retrieved on 02:44, 23 November 2020 (UTC)</ref>. It was the same as the current definition noted above but had another typo that made it ill-defined. |
||
== Sources == |
== Sources == |
||
| Line 110: | Line 93: | ||
[[Category:Notations]] |
[[Category:Notations]] |
||
[[Category:Functions]] |
[[Category:Functions]] |
||
| − | [[Category:Incomplete]] |
||
| − | [[Category:Numbers by Nirvana Supermind]] |
||
Revision as of 06:36, 23 November 2020
Quick array notation is a notation for large numbers made by Wikia user Nirvana Supermind[1]. The notation is currently composed of 1 extension , which is as follows:
Linear array notation
Linear array notation is the first part of quick array notation.
Current version
All information here only applies to the current version of the notation, which is given after the issues on the original definition were pointed out.
Definition
The linear notation has the following form:
Q<a,b,c,d,e…>
The rules for it are:
- Q<> = Q<a> = 0
- Q<a,b> = a*b
- Q<#,0> = Q<#>
- Q<a,1,#> = a for b>0
- Q<a,b,c,#> = Q<a,Q<a,b-1,c,#>,c-1,#> for b>0
Here # denotes a portion of the array, which can 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. If none of the 3 rules above applies, start the process shown below starting from the third entry inside the brackets:
- Case A: If the entry is 0, jump to the next entry.
- Case B: If the entry is not 0, then:
- Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array.
- Replace all entries before the “b,n-1” with a (the first entry).
- Terminate the process. Repeat if the rules still do not apply.
The creator stated that this extension most likely reaches ωω in the fast-growing hierarchy.
An old version of the notation had some typos that made it ill-defined, but the creator has fixed them since then[3]. There is a more in-depth explanation of this in the "Original version" section.
Example
Q<3,2,1>
= Q<3,Q<3,1,1>,0>
= Q<3,Q<3,1,1>>
= Q<3,3>
= 3*3
= 9
Original version
All information here only applies to the old version of the notation.
Definition
The domain is perhaps intended to be the set of all arrays of non-negative integers, although the original definition has a typo "Where are nonnegative integers" of "Where a, b, c, and so on are nonnegative integers" or something like that.[3] It has the following rules:
- Q<> = Q<a> = 0
- Q<a,b> = a*b
- Q<#,0> = x<#>
- Q<a,1,#> = a for b>0
- Q<a,b,c,#> = x<a,x<a,b-1,c,#>,c-1,#> for b>0
Here # denotes a portion of the array, which can be empty, and x denotes some number. In the original source, it is written "the outer number x is called the iterator, and it". 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.
If none of the 3 rules above applies, start the process shown below:
- Case A: If it’s 0, jump to the next entry.
- Case B: If the entry is not 0, then:
- Replace the “0,n” with “b,n-1” where n is this entry and b is the second entry of the array.
- Replace all entries before the “b,n-1” with a (the first entry).
- Terminate the process. Repeat if the rules still do not apply.
This notation is intended to reach ωω in the fast-growing hierarchy by the creator, but is ill-defined mainly because x, which is called "it", is undefined.
Example
Let us compute Q<0,0,0>. The resulting expression is x<0,0> for some x, because the third rule is applicable. Since there is no rule applicable to x<0,0>, we need to start the exceptional process. In Case A, the process refers to "it". Since the terminology of "it" is quite ambiguous, there are two possibilities:
- The "it" means the current entry to which the process refers.
- The "it" means x.
In the first interpretation, there is no clarification of what entry the process refers to first. Perhaps it should be the first entry of the array following the outer iterator x. Since the first entry is 0, Case A is applicable. Then the current entry becomes the next 0, and hence Case A is applicable again. However, there is no entry next to the current entry, and hence the process does not terminate in a usual way.
In the second interpretation, then Case A does not change it. Therefore the process for x<0,0> causes an infinite loop if the undefined x is 0. In any case, the reference to the undefined value x is invalid. As a result, x<0,0> and hence Q<0,0,0> are ill-defined. In particular, the analysis by the creator is wrong.
Second version
There is also a second old version of this notaion in an attempt to fix it.[4]. It was the same as the current definition noted above but had another typo that made it ill-defined.
Sources
- ↑ Quick array notation (Retrieved at (UTC) 6:30 22/11/2020)
- ↑ Linear array notation (Retrieved at UTC 6:30 22/11/2020)
- ↑ 3.0 3.1 3.2 Linear array notation (Retrieved at (UTC) 10:30 20/11/2020)
- ↑ Linear array notation retrieved on 02:44, 23 November 2020 (UTC)