**EDIT: **I am closing this blog post because I found out about this.

This blog post was made to explain how SAN works, for each one of it's parts.

WIP!

## How to LAN

First, we have the 3 base rules (let @ is the rest of the array and $ is a copy of that @):

- s(a,b) = a
^{b}(2-entry case) - s(@,1) = s($) (removing unnecesary 1's)
- s(a,b,c @) = s(a,s(a,b-1,c $),c-1 $) (recursion on the second entry)

For 2-entry arrays, s(a,b) = a^{b}, by using the first rule.

For 3-entry arrays:

- s(a,b,1) = s(a,b) = a
^{b}, by using the second rule. - s(a,b,2) = s(a,s(a,b-1,2),1) = s(a,s(a,s(a,b-2,2),1),1) = ... = s(a,s(a,s(...s(a,1,2)...),1),1) = s(a,s(a,s(...s(a,s(a,0,2),1)...),1),1) = ...

This gives us an infinite loop. To solve this, we need to add another rule:

- s(a,1 @) = a

Now we can continue:

- s(a,b,2) = s(a,s(a,s(...s(a,1,2)...),1),1) (nested b times) = s(a,s(a,s(...a...),1),1) (nested b times) = s(a,s(a,s(...a...))) (nested b times) = a
^{a...a}(nested b times) =^{b}a. - s(a,b,3) = s(a,s(a,s(...s(a,1,3)...),2),2) (nested b times) = s(a,s(a,s(...a...),2),2) (nested b times)
^{a...a}a (nested b times) = a↑↑↑b - s(a,b,4) = s(a,s(a,s(...s(a,1,4)...),2),2) (nested b times) = s(a,s(a,s(...a...),2),2) (nested b times) = a↑↑↑a↑↑↑...↑↑↑a (nested b times) = a↑↑↑↑b

We can see a pattern here. s(a,b,1) = a^{b}, s(a,b,2) = ^{b}a, s(a,b,3) = a↑↑↑b, s(a,b,4) = a↑↑↑↑b, and s(a,b,c) = a↑^{c}b.

Now, how can we extend this notation to allow more entries? Here is a way of extending past 3 entries, which matches up with SAN.

First, we need to introduce ordinal arrays. In SAN, a valid expression is of the form s(a,b,A), where A is an ordinal array.

Ordinal arrays can be sequence ordinal arrays or limit ordinal arrays. If the first entry of the ordinal array is not 1, it's a sequence ordinal array, and else it's a limit ordinal array (1 is the only exception to this rule, since it's a sequence ordinal array).

If an ordinal array is a limit ordinal array, it will have a fundamental sequence, and the nth term of the fundamental sequence of ordinal array A is FS[A|n].

If an ordinal array is a sequence ordinal array, it will have a predecessor. The predecessor of array A is A-1, and A-1 is calculated by decreasing the first entry of A by 1.

The only ordinal array left that we have to define is 1,2. FS[1,2|x] = x. To calculate the fundamental sequences of the rest of the limit ordinal arrays, we need to define some stuff.

First is the ordinal array addition operator +. The sum of arrays A and B is (A)+(B). If we add two ordinal arrays, and the second one is a sequence ordinal array, we add the values of the entries of each of the ordinal arrays to get the values of the entries of the result (value of nth entry of first ordinal array + value of nth entry of second ordinal array = value of nth entry of the result).

However, if the second ordinal array is a limit array, FS[(A)+(B)|x] = (A)+(FS[B|x]).

Next is the ordinal array multiplication operator. The product of arrays A and B is (A)*(B). When multiplying an ordinal array of the form #,2 (where # is a chain of entries, all with value 1, and % is a copy of that #), if ordinal array A is a sequence ordinal array, (#,2)*(A) = %,A, and FS[(#,2)*(A)|x] = (#,2)*(FS[A|x]) otherwise.

And finally, we need to define the entry replacement function R[x|y]. If x is of the form FS[A|z], where A is a limit ordinal array, find the key entry (the entry such that that entry has value w in FS[A|w]) and replace all entries before the key entry with y.

We can use these operators to calculate the fundamental sequences of other limit ordinal arrays. For example, 1,1,2 = (1,2)*(1,2), and it's fundamental sequence is FS[(1,2)*(1,2)|x] = (1,2)*(FS[1,2|x]) = (1,2)*(x).

Finally, we can add the new rule:

- If A is a limit ordinal array, s(a,b,A) = s(a,a,R[FS[A|b]|a]).

## How to exAN

## How to EAN

## How to mEAN

## How to pDAN

## How to sDAN

## How to DAN

## How to NDAN

## How to WDEN

## How to mWDEN

## How to WDmEN

## How to pDDN

## How to sDDN

We can see a pattern here...

[coming after hyp cos finishes fully analyzing SAN]