Rampant Array Notation

Rampant Array Notation is an array notation developed by Googology Wiki user Nirvana Supermind. The goal of it is to eventually catch up with the BEAF, BAN, and most other major notations and become one of the fastest notations. However, BEAF is known to be ill-defined beyond tetrational arrays, and hence the comparison does not make sense with UdRaN (which corresponds to expandal BEAF). It is composed of 6 extensions, 2 of which have been finished:

• Basic Rampant Array Notation (BRAN)
• Linear Rampant Array Notation (LRAN)
• Quadratic Rampant Array Notation (QRAN)
• Dimensional Rampant Array Notation (DRAN)
• Bidimensional Rampant Array Notation (BdRAN)
• Ultradimensional Rampant Array Notation (UdRAN)

The two are ill-defined in the original definition while the creator insists that they are well-defined even after issues are clearly pointed out, but the creator changed the description of the definition.

Although it is not clarified in the current definition and the original definition, the range and domain of the notation is nonnegative integers according to the creator. However, the creator substitutes not only a nonnegative integer, but also an array of nonnegative integers. Therefore the description of the domain is inconsistent with the actual explanation. Therefore the declaration of the domain and the range should be ignored unless they will be clarified and fixed.

Basic notation

Basic Rampant Array Notation takes two entries. It is defined as:

1. r() = 0
2. r(a) = a^2
3. r(#,0) = r(#)
4. r(a,b) = r(r(r(a,b-1),b-1),b-1…) with “a” times for b>0

Here # denotes a portion of the array. It can also be empty.

Example

r(3,1) = r(r(r(3,0),0),0…) with 3 times r(3,1) = r(r(r(3,0),0),0) r(3,1) = ((3^2)^2)^2 r(3,1) = 6561

In the original definition, which the creator insists the well-definedness from the beginning, r() was ill-defined and r(3,0) admits two distinct ways to evaluate.

Linear notation

Linear Rampant Array Notation takes any amount of entries, so it is the limit of vanilla arrays/tuples. The rules are:

1. r() = 0
2. r(a) = a^2
3. r(#,0) = r(#)
4. r(a,b,#) = r(r(r(a,b-1,#),b-1,#),b-1,#…) with “a” times for b>0

These rules are incomplete, and there are edge cases where they don't work (e.g. r(a,0,1)). So we begin a process if the rules dont work:

Start from the second-to-last entry, and move backwards.

1. If you hit an entry which is 0, then turn the entry into “a” (the first entry) and decrease the following entry by 1.
2. Otherwise, stop the process.

Example

r(2,1,0,1) = r(r(2,0,0,1),0,0,1) r(2,0,0,1) = r(2,2,2,2) r(2,2,2,2) = r(r(2,2,2,1),2,2,1) r(2,2,2,1) = r(r(2,2,2),2,2) r(2,2,2,2) = r(r(r(2,2,2),2,2),2,2,1) r(2,0,0,1) = r(r(r(2,2,2),2,2),2,2,1) r(2,1,0,1) = r(r(r(r(2,2,2),2,2),2,2,1),0,0,1) r(2,1,0,1) = r(r(r(r(2,2,2),2,2),2,2,1),r(r(r(2,2,2),2,2),2,2,1),r(r(r(2,2,2),2,2),2,2,1)) …