**Prev**: Dropping array notation **Next**: Dropper-expanding notation

Note: this version of the notation doesn’t work.

Nested dropper array notation (NDAN) is the eighth part of my array notation. In this part, the definition will change a lot.

Symbol △ is called *triangle*, with unicode = 9651 and LaTeX = \triangle

Symbol ○ is called *circle*, with unicode = 9675 and LaTeX = \circ

Let the triangle be a high-leveled separator. And we use a pair of parentheses to be a prefix of separators. If A is a separator, then we can have (m)A for some A, where m is a positive integer.

(1)A is a 1-separator, (2)A is a 2-separator, (3)A is a 3-separator, and so on. When this prefix is applied on the triangle, then (1)△ is the grave accent – the least 1-separator, (2)△ is the double comma – the least 2-separator, (3)△ is the triple comma – the least 3-separator, and so on.

In DAN, the (m)-separator (m)△ solves in this way: Search out for a separator A_{u(m)} that has lower level than it, then B_{u(m)} becomes (m-1)B_{u(m)}. As a (m-1)-separator, the (m-1)B_{u(m)} search out for a separator A_{u(m-1)} that has lower level than it. If it has lower level than “X Y” (where (m-1)B_{u(m)} = “X (m)B_{u(m+1)} 2 Y” = “X (m)△ 2 Y”), then add “X Y” somewhere inside B_{u(m-1)}. Or B_{u(m-1)} becomes (m-2)B_{u(m-1)}. Continue downward, until (1)B_{u(2)}. Finally B_{u(1)} = “P (1)B_{u(2)} Q”, then it expands.

So, an (m)A drops down to (m-1)B, and {P (1)A Q} expands. So the ()-prefix is called *dropper*. But in DAN, all the dropping process are inside one rule, and it can just drop finite times, meaning that we cannot have (1,2) dropper, (1`2) dropper, etc. In NDAN, we can because the “case B2” is separated into several parts. The “1,2” in (1,2)A reduces in normal comma way, and the “1`2” in (1`2)A reduces in normal way (just search out, it doesn’t matter if you’re inside a dropper).

Next, let the circle be a high-leveled dropper. We can have (1(1)△2)△ = (1`2)△, (1(2)△2)△ = (1,,2)△, (1(3)△2)△ = (1,,,2)△, (1(1,2)△2)△, (1(1(1,2)△2)△2)△, and so on. ○△ is a high-leveled separator, and (2)○△ is the 1-separator of ( ____ )△ – it’s the least 1-separator in a dropper! If A is a dropper and B is a no-prefixed separator, then (1)AB is a 1-separator of dropper, (2)AB is a 2-separator of dropper, etc. If A and B are droppers, C is a no-prefixed separator, then (1)ABC is a 1-separator of dropper of dropper, (2)ABC is a 2-separator of dropper of dropper. And (1)○○○△, (1)○○○○△, etc. – all these lead to the full **nested** dropper array notation.

# Definition

Syntax:

- s(a,b) is an array where a and b are positive integers.
- s(#Am) is an array, where m is a positive integer, A is a separator, and # is a string such that s(#) is an array.

Definition of separators:

- The m-ple comma (,,…,) with m ≥ 2 are separators. (basic separators)
- {m} is a separator, where m is a positive integer.
- {#Am} is a separator, where m is a positive integer, A is a separator, and # is a string such that {#} is a separator.
- AB is a separator, where A is a dropper and B is a separator.

Definition of droppers:

- The ○ is a dropper.
- (m) is a dropper, where m is a positive integer.
- (#Am) is a dropper, where m is a positive integer, A is a separator, and # is a string such that (#) is a dropper.

Note:

- The comma (,) is a shorthand for {1}.
- The grave accent ` = (1)△, the double comma ,, = (2)△, the triple comma ,,, = (3)△, and so on, the m-ple comma ,,…, = (m)△ where m ≥ 2.
- When a separator A = A
_{1}A_{2}…A_{k-1}A_{k}, where A_{1}, A_{2}, …, A_{k-1}are dropper and A_{k}is a single separator (not jointed by a dropper and a separator), we say A_{1}, A_{2}, …, A_{k-1}, A_{k}are*sections*in separator A.

## Rules and process

- Rule 1: (base rule – only 2 entries) s(a,b) = a^b
- Rule 2a: (tailing rule – the last entry is 1) s(# A 1) = s(#), {# A 1} = {#} and (# A 1) = (#)
- Rule 3: (recursion rule – neither the 2nd nor 3rd entry is 1) s(a,b,c #) = s(a, s(a,b-1,c #) ,c-1 #)

where # is a string of entries and separators, it can also be empty. A is a separator.

If none of the 3 rules above applies, start the process shown below. Note that case B1, B2, B4 and B5 are terminal but case A and B3 are not. b, n, M, B_{t}′s and K are parts of the original array but t, i, S_{i}, A_{t}′s, P and Q are not. Before we start, let A_{0} be the whole array. First start from the 3rd entry.

- Case A: If the entry is 1, then you jump to the next entry.
- Case B: If the entry n is not 1, look to your left:
- Case B1: If the comma is immediately before you, then
- Change the “1,n” into “b,n-1” where n is this non-1 entry and the b is the iterator.
- Change all the entries at base layer before them into the base.
- The process ends.

- Case B2: If a separator (1)M (where M is the remaining sections) is immediately before you, then
- Let t be such that the (1)M is are layer t. And let B
_{0}be the whole array now. - Repeat this:
- Subtract t by 1.
- Let separator B
_{t}be such that it’s at layer t, and the (1)M is inside it. - If t = 1, then break the repeating, or else continue repeating.

- Find the maximum of t such that lv(A
_{t}) < lv((1)M). - If lv(A
_{t}) < lv(D(M)), then- Find the minimum of v such that v > t and lv(A
_{v}) < lv(U(M)). - Let string P and Q be such that B
_{t}= “P B_{v}Q”. - Change B
_{t}into “P X(M) A_{v}Y(M) Q”. - The process ends.

- Find the minimum of v such that v > t and lv(A
- If lv(A
_{t}) ≥ lv(D(M)), then- Let string P and Q be such that B
_{t}= “P (1)M n Q”. - Change B
_{t}into S_{b}, where b is the iterator, S_{1}is comma, and S_{i+1}= “P S_{i}2 (1)M n-1 Q”. - The process ends.

- Let string P and Q be such that B

- Let t be such that the (1)M is are layer t. And let B
- Case B3: If a separator K is immediately before you, and it doesn’t fit case B1 or B2, then
- Change the “K n” into “K 2 K n-1”.
- Set separator A
_{t}= K, here K is at layer t. - Jump to the first entry of the former K.

- Case B4: If an lbrace is immediately before you, then
- Change separator {n #} into string S
_{b}, where b is the iterator, S_{1}= “{n-1 #}” and S_{i+1}= “S_{i}1 {n-1 #}”. - The process ends.

- Change separator {n #} into string S
- Case B5: If a “(” is immediately before you, then
- Let t be such that the separator (n #)M is are layer t, here (n #) is the first section and M is the remaining sections. And let B
_{0}be the whole array now. - Repeat this:
- Subtract t by 1.
- Let separator B
_{t}be such that it’s at layer t, and the (n #)M is inside it. - If t = 1, then break the repeating, or else continue repeating.

- Find the maximum of t such that lv(A
_{t}) < lv((n #)M). - If lv(A
_{t}) < lv(D(M)), then- Find the minimum of v such that v > t and lv(A
_{v}) < lv(U(M)). - Let string P and Q be such that B
_{t}= “P B_{v}Q”. - Change B
_{t}into “P X(M) A_{v}Y(M) Q”. - The process ends.

- Find the minimum of v such that v > t and lv(A
- If lv(A
_{t}) ≥ lv(D(M)), then- Change B
_{t}into “(n-1 #)A_{t}“. - The process ends.

- Change B

- Let t be such that the separator (n #)M is are layer t, here (n #) is the first section and M is the remaining sections. And let B

- Case B1: If the comma is immediately before you, then

## Level comparison

All arrays have the lowest and the same level. Then the “+” has the highest level, the triangle has the second highest level. And note that the same separators have the same level. To compare levels of other separators A and B, we follow these steps.

- Compare levels of the last section of A and B using
. If lv(last section of A) < lv(last section of B), then lv(A) < lv(B); if lv(last section of A) > lv(last section of B), then lv(A) > lv(B); or else –*normal rules* - If A has only 1 section but B has more than 1 sections, then lv(A) > lv(B); if A has more than 1 sections but B has only 1 section, then lv(A) < lv(B); if both A and B have only 1 section, then lv(A) = lv(B); or else –
- Let A = “#
_{1}(P) M” where M is the last section and (P) is the second last section, B = “#_{2}(Q) N” where N is the last section and (Q) is the second last section. - If lv(“#
_{1}{P}”) < lv(“#_{2}{Q}”), then lv(A) < lv(B); if lv(“#_{1}{P}”) > lv(“#_{2}{Q}”), then lv(A) > lv(B); if lv(“#_{1}{P}”) = lv(“#_{2}{Q}”), then lv(A) = lv(B). Note that if (P) (or (Q)) is the circle, then {P} (or {Q}) is the triangle.

Normal rules:

- Apply rule 2 to A and B until rule 2 cannot apply any more.
- Let A = {a
_{1}A_{1}a_{2}A_{2}…a_{k-1}A_{k-1}a_{k}} and B = {b_{1}B_{1}b_{2}B_{2}…b_{l-1}B_{l-1}b_{l}} - If k = 1 and l > 1, then lv(A) < lv(B); if k > 1 and l = 1, then lv(A) > lv(B); if k = l = 1, follow step 4; if k > 1 and l > 1, follow step 5 ~ 10
- If a
_{1}< b_{1}, then lv(A) < lv(B); if a_{1}> b_{1}, then lv(A) > lv(B); if a_{1}= b_{1}, then lv(A) = lv(B) - Let , and .
- If lv(A
_{maxM(A)}) < lv(B_{maxM(B)}), then lv(A) < lv(B); if lv(A_{maxM(A)}) > lv(B_{maxM(B)}), then lv(A) > lv(B); or else – - If |M(A)| < |M(B)|, then lv(A) < lv(B); if |M(A)| > |M(B)|, then lv(A) > lv(B); or else –
- Let A = {#
_{1}A_{maxM(A)}#_{2}} and B = {#_{3}B_{maxM(B)}#_{4}} - If lv({#
_{2}}) < lv({#_{4}}), then lv(A) < lv(B); if lv({#_{2}}) > lv({#_{4}}), then lv(A) > lv(B); or else – - If lv({#
_{1}}) < lv({#_{3}}), then lv(A) < lv(B); if lv({#_{1}}) > lv({#_{3}}), then lv(A) > lv(B); if lv({#_{1}}) = lv({#_{3}}), then lv(A) = lv(B)

## Subfunctions

4 subfunctions appear in the process: U, D, X and Y function. The inputs of them are separators, the outputs of U and D are separators, and the outputs of X and Y are strings.

The primitive definitions of U, D, X and Y are as follows. If A = ○○…○△ (there also can be no circles), then

- U(A) = “+”
- D(A) = “,”
- X(A) = “{1”
- Y(A) = “2}”

For other A such that the first section of A is neither △ nor ○, U(A), D(A), X(A) and Y(A) are determined in those steps:

- Start the process, and start from the first entry of B. But we use case A, B3 and B5 only. Until we meet case B5.
- When we meet case B5, don’t go into it. Let string P and Q be such that A = “P (n #)M 2 Q”.
- Define U(A) = “(n #)M”, D(A) = “P Q”, X(A) = “P” and Y(A) = “2 Q”.

# Explanation

In the process, the case B2 is the dropping and expanding of 1-separators. The case B5 is the dropping of higher-separators. The four functions, U, D, X and Y are the linking between different “drop down process”.

Since U(○○…○△) = “+”, when it drops in case B5, and we jump into step 4, “lv(A_{v}) < lv(U(M))” is always true, so v = t+1.

Pay attention to the step 2 of the 4 new rules in level comparisons. It means that “(P)M” always have lower level than M. In step 5 of case B5 in the process, the B_{t} becomes “(n-1 #)A_{t}“, so the level of it reduces.

Since we separate the dropping process into several parts, we’ll meet case B3 more often. Every time we meet case B3, it pulls the K out, so NDAN is not exactly the same as DAN even below (1,2)△. The simplest example, s(a,b{1{1(2)△2}3}2) = s(a,b{1(1){1(2)△2}2{1(2)△2}2}2) = s(a,b{1…{1{1,2(1){1(2)△2}1{1(2)△2}2}2(1){1(2)△2}1{1(2)△2}2}…2(1){1(2)△2}1{1(2)△2}2}2) with b-1 (1){1(2)△2}′s. After many steps, s(a,b{1(1){1(2)△2}1{1(2)△2}2}2) = s(a,b{1(1){1(2)△2}1(1){1(2)△2}2{1(2)△2}1}2) = s(a,b{1(1){1(2)△2}1(1){1(2)△2}2}2), and it has growth rate , so s(n,n{1{1(2)△2}3}2) has growth rate , while s(n,n{1{1,,2}3}2) has growth rate in DAN. But both s(n,n{1{1,2(2)△2}2}2) and s(n,n{1{1,2,,2}3}2) have growth rate , so this difference doesn’t matter the final strength of DAN and NDAN.