Hyperarrow Array

The default array is and it is equal to n↑n

- all 0's and 1's are ignored

The first notation is called "Basic Hyperarrow Array" and it is any array with up to 3 entries.

First System

n↑(a) = n↑an

n↑(a,b) = n↑(n↑(a↑(b)))

n↑(a,b,c) = n↑(n↑,a↑(a↑,b↑(b,c↑(a,b))))

Separate rule for arrays with more than 3 enties, also called an "Extended Hyperarrow Array"

n↑(a1,a2,a3,....,al,am,ax) = n↑(n↑(a1,a2,a3↑(a4,a5,a6↑(a7,a8,a9↑.....,↑(al,am,ax))..))))

Basically, repeat n↑ 2 times (appears to be rule for all arrays), then break the rest down into triple arrays. (or if the last elements don't group into 3, you will see what to do in the example below:

Eg: 3↑(4,5,6,7,8) = 3↑(3↑(4,5,6↑(7,8)))

n↑(#) = n↑(#,0) = n↑(n,n,n,n,.....,n), where in the array "n" repeats n times.

n↑(#,a) = n↑(n,n,n,.....,n), where in the array "n" repeats n↑(#,a-1) times.

n↑(#,#) = n↑(#,n) = n↑(n,n,n....,n), where in the array "n" repeats n↑(#,n) times.

n↑(#,#,a) = n↑(n,n,n,n...n,n), where in the array "n" repeats n↑(#,#,a-1) times.

n↑(#,#,#) = n↑(#,#,n)

Same rules for however many entries with # we have.

n↑(@) = n↑(#,#,#,...,#,#), with n #'s

n↑(@,a) = n↑(#,#,#,#,#,...,#), with n↑(@,a-1) #'s.

n↑(@,@) = n↑(@,a)

n↑(@,@,a) = n↑(#,#,#,....,#) ,with n↑(@,@,a-1) #'s.

Same iterating rules that we had with #'s.

Then we define "&" which does the same style of iteration that the previous 2 did, except this time we iterate @'s.

And so, we can define however many iterators we want, denoted with "!n"

!1 = #

!2 = @

!3 = &

and so on.

Eg: 3↑(!100)

Third System

n↑((a)) = n↑(!a)

n↑((a,b)) = n↑((n↑((a↑((!b))))))

n↑((a,b,c)) = n↑((n↑,a↑((a↑,b↑((b,c↑((a,b))))))))

n↑((a1,a2,a3,....,al,am,ax)) = n↑((n↑((a1,a2,a3↑((a4,a5,a6↑)(a7,a8,a9↑.....,↑((al,am,ax))..))))

Same rules of the first part, but replace everything with doube parantheses. Same iteration rules with #,@,and & that the first part had.

Get ready for some complicated things

We have the same iterators, but now #2,@2,&2, and !n2 that do the EXACT same iteration style that the first ones did.

Define a 3rd system with the same rules that the second one had, but replace everything with the new iterators explained above and use triple parantheses.

Eg: n↑(((a))) = n↑((!a2))

Keep on defining systems with rules based off the second one, just like we defined the third one.

Now, finally,

n↑↑(a) = n↑(a!aa) (where the first subscript a indicates parantheses recursion)