User blog:GamesFan2000/A more detailed explanation of HSAN

Hyper-Strong Array Notation is a notation I defined in brief in a previous post. However, I wasn't really satisfied with the definitions given, so I decided to give a more detailed explanation, while changing up the rules.

Terminology
Here are some terms to remember:

The array is the structure in which everything happens, represented by brackets and a finite number of "entries"

The base is the first entry of the array, represented by b

The prime is the second entry of the array, represented by p

The pilot is the last entry of the array, represented by n

The co-pilot is the last non-one entry before the pilot, represented by c

Process
Rule 1: If the base is equal to zero, the array defaults to zero. If the base is equal to 1, the array defaults to 1.

Rule 2: If there are only two entries, proceed with the following:

Step 1: Look at the second entry. The second entry determines the operation level. The operation level is p+1. Level 1 is addition, level 2 is multiplication, and so on. If the second entry equals 1 at the beginning, then don't perform anything and crop out the 1. The array defaults to the base.

Step 2: Look at the base. You will create a repeated operation with b b's. The answer will become the new base. Reduce the second entry by 1.

Step 3: Repeat the process until the second entry equals 1. Crop out the 1. The answer to the array is whatever the final operation yielded.

Rule 3: For three entries or larger, proceed with the following:

Step 1: Look at the pilot. If the pilot is larger than 1, skip to Step 2. If the pilot is 1, crop it. If there are 1's between the co-pilot and the pilot, the co-pilot will replace the 1's between it and the pilot. If there are only three entries, skip straight to step 4.

Step 2: Look at the pilot and co-pilot. The co-pilot determines the operator. The operator level is c+1. Look at the pilot. Create a repeated operation with n n's. The answer will replace n. Reduce c by 1. Repeat until c =1. This means that it is no longer the co-pilot. The last non-one entry before it will become the co-pilot. Ignore the 1's and don't crop them out. With the new co-pilot, use the same process as before, with the same parameters. Repeat this process.

Step 3: Eventually, the prime will become the co-pilot. Likewise, continue with Step 2 until the prime equals 1. At this point, the base becomes the co-pilot. Now, we switch up the process. Remove one of the 1's from the array, and replace all of the others with the base. Repeat Steps 2 and 3 until you get down to three entries.

Step 4: This step is only commenced once you've reduced the entry total to three. If you started with three entries, skip straight to this. Look at the pilot. The pilot now determines the operator. The operator level is n+1. Look at the prime. Create a repeated operation with p p's. The answer will replace p. Reduce n by 1. Repeat until n = 1. You will now crop out the 1. Refer to Rule 2 from this point onwards.

Two-Entry Arrays
{2, 2} = 2^2 = 4

{3, 2} = 3^3^3 = 3^27

{2, 3} = {2^^2, 2} = {4, 2} = 4^4^4^4 = 4^4^256

{5, 2} = 5^5^5^5^5 = 5^5^5^3125

{3, 3} = {3^^3^^3, 2}

{4, 4} = {4^^^4^^^4^^^4, 3}

Three-Entry Arrays
{2, 2, 2} = {2, 4, 1} = {2, 4}

{3, 3, 3} = {3, 3^^3^^3, 2}

{4, 4, 4} = {4, 4^^^4^^^4^^^4, 3}

Four-Entry Arrays
{2, 1, 1, 1} = {2, 2, 2}

{2, 2, 1, 1} = {2, 2, 2}

{2, 2, 2, 1} = {2, 2, 2}

{2, 1, 1, 2} = {2, 2, 2}

{2, 1, 2, 2} = {2, 2, 1, 2} = {2, 1, 1, 4} = {2, 2, 4}

{2, 2, 2, 2} = {2, 2, 1, 4}

{3, 3, 3, 3} = {3, 3, 2, 3^^3^^3}

{4, 4, 4, 4} = {4, 4, 3, 4^^^4^^^4^^^4}