Weak dropper-multiexpanding notation

Prev: Multiple weak dropper-expanding notation Next: Primary dropper-dropping notation

Weak dropper-multiexpanding notation (WDmEN) is the eleventh part of my array notation. To get the idea of this part, we first go over pDAN, DAN, NDAN and WDEN.

In mWDEN, the :` work as the : in { ____ <sup>:</sup>} separators, the :` ` works as the : in { ____ <sup>:`</sup>} separators, and so on. Now we can do something similar to pDAN. We bring a new separator – the colon followed by a comma (i.e. the “:,”), then {A :, 1} is {A}, {A :, 2} is {A^:}, {A :, 3} is {A^:`}, and generally {A :, m} is {A^:m-1}. So the :, is not simply the 2-separator on { ____ ^:} separators. Instead, it’s the 2-separator over the colon, because it works similar to the colon after one dropping.

Now we do something similar to DAN. the :,, is the 3-separator over the colon, :,,, is the 4-separator over the colon, and so on. Generally the colon followed by m commas is the (m+1)-separator over the colon, which works similar to the colon after m droppings.

Now we do something similar to NDAN. To express “work similar to the colon” we need an extra dropper, and it looks like this:

(1)²

where the 2 is at the superscript position of the rbrace. (1)²{#} expands to (1)(#)(#)…(#){#} with b-1 (#)′s (where b is the iterator). As a result, (2)² is the dropper for “work similar to the colon”, (3)² is the dropper for “2-separator over the colon”, (4)² is the dropper for “3-separator over the colon”, and so on.

But the “NDAN over the colon” doesn’t end here. Suppose that {1::2} is a high-leveled separator, with D({1::2}) being the comma, then (2)²{1::2} is the colon, (3)²{1::2} is :, and (m)²{1::2} is the colon followed by m-2 commas. Continue upward, (1)(1::2)²{1::2} is the 1-separator on ( ____ )²{1::2}, (1)(1::2)(1::2)²{1::2} is the 1-separator on ( ____ )(1::2)²{1::2}, (1)²(1::2)(1::2)²{1::2} expands to (1)(1::2)(1::2)…(1::2)(1::2)²{1::2} with b-1 (1::2)′s, so (2)²(1::2)(1::2)²{1::2} works similar to the colon on ( ____ )(1::2)²{1::2}. (1)²(1::2)²{1::2}, which is higher-leveled than (1)²(1::2)(1::2)²{1::2}, expands to (1)(1::2)²(1::2)(1::2)²(1::2)…(1::2)²{1::2} with b-1 (1::2)²′s, because we still have an extra rule – (1)² search right for a dropper lower-leveled than it.

Now we do something similar to WDEN. The double colon (::) is a separator such that {1 :: 1 :: … 1 :: n #} expands to (1)(1 :: 1 :: … 1 :: n #)²……(1 :: 1 :: … 1 :: n #)²{1 :: 1 :: … 1 :: n #} with b-1 (1 :: 1 :: … 1 :: n #)²′s. The :: is again similar to the colon, but the dropper-expanding results (#)² droppers instead of (#) droppers.

The next step is (1)³ – the dropper for (#)²-dropper-expanding, and (2)³ is the dropper for the double colon. We also have (1)⁴, (1)⁵, and so on. But all the (1)^m (where m > 1) search right for a dropper lower-leveled than them. By the way, if the first lower-leveled one is even lower-leveled than (1)^m-1, then change the (1)^m#(A)^k into (1)^m#(A)^m-1(A)^k – that’s similar to what we do at the end of mEAN.

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:

• {m} is a separator, where m is a positive integer.
• ::…: with m colons 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:

• (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.
• (#)^m is a dropper, where m is a positive integer, and # is a string such that (#) is a dropper.

Note:

1. The comma is a shorthand for {1}.
2. The grave accent is a shorthand for (1){1 : 2}. The colon is a shorthand for (2)²{1 :: 2}, the double colon is a shorthand for (2)³{1 ::: 2}, and so on.
3. (#)¹ is the same thing as (#).

For separator A, define F(A,n) to be the n-th sections of A, with (#)^m changed into {#}^m. Generally, if (A)^a is a dropper and B is a separator, then F((A)^aB,1) = {A}^a and F((A)^aB,n) = F(B,n-1) for n > 1.

Note that {#}^m (where m > 1) is not a separator, but we call it preseparator.

Rules and process

• Rule 1: (base rule – only 2 entries) s(a,b) = a^b
• Rule 2: (tailing rule – the last entry is 1) s(# A 1) = s(#), {# A 1} = {#} and (# A 1)^m = (#)^m
• 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, B3, B5 and B6 are terminal but case A and B4 are not. b, n, m, 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₀ and F(A₀,1) 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
    1. Change the “1,n” into “b,n-1” where n is this non-1 entry and the b is the iterator.
    2. Change all the entries at base layer before them into the base.
    3. The process ends.
  • Case B2: If a separator (1)M (where M is the remaining sections) is immediately before you, then
    1. Let t be such that the (1)M is are layer t. And let B₀ be the whole array now.
    2. Repeat this:
       1. Subtract t by 1.
       2. Let separator B_t be such that it’s at layer t, and the (1)M is inside it.
       3. If t = 1, then break the repeating, or else continue repeating.
    3. Find the maximum of t such that lv(A_t) < lv((1)M).
    4. If lv(F(A_t,1)) < lv(D(F(M,1))), then
       1. Find the minimum of v such that v > t and lv(A_v) < lv(U(M)).
       2. Let string P and Q be such that B_t = “P B_v Q”.
       3. Change B_t into “P X(M) A_v Y(M) Q”.
       4. The process ends.
    5. If lv(F(A_t,1)) ≥ lv(D(F(M,1))), then
       1. Let string P and Q be such that B_t = “P (1)M n Q”.
       2. Change B_t into S_b, where b is the iterator, S₁ is comma, and S_i+1 = “P S_i 2 (1)M n-1 Q”.
       3. The process ends.
  • Case B3: If a separator (1)^mM (where m > 1, M is the remaining sections) is immediately before you, then
    1. Find the minimum of t such that lv(F(M,t)) < lv({1}^m).
    2. If lv(F(M,t)) < lv({1}^m-1), then
       1. Let string P and Q be such that P is the first t-1 sections of (1)^mM and (1)^mM = “P Q”.
       2. Change the “(1)^mM n” into “P(1 (2)^mM 2)^m-1Q 2 (1)^mM n-1″.
       3. For sections of the “P(1 (2)^mM 2)^m-1Q”, if it’s not the last one, convert “{#}” into “(#)”; if it’s the last one, convert “(#)” into “{#}”.
       4. The process ends.
    3. If lv(F(M,t)) ≥ lv({1}^m-1), then
       1. Change the “(1)^mM n” into “S_bM 2 (1)^mM n-1″, where b is the iterator, S₁ is “(1)” and S_i+1 = “S_i P_t-1“, where P₀ is empty string and P_i+1 = “P_i F(M,i+1)”.
       2. For sections of the “S_bM”, if it’s not the last one, convert “{#}” into “(#)”; if it’s the last one, convert “(#)” into “{#}”.
       3. The process ends.
  • Case B4: If a separator K is immediately before you, and it doesn’t fit case B1, B2 or B3, then
    1. Change the “K n” into “K 2 K n-1”.
    2. Set separator A_t = K, here K is at layer t.
    3. Jump to the first entry of the former K.
  • Case B5: If an lbrace is immediately before you, then
    1. Change separator {n #} into string S_b, where b is the iterator, S₁ = “{n-1 #}” and S_i+1 = “S_i 1 {n-1 #}”.
    2. The process ends.
  • Case B6: If a “(” is immediately before you, then
    1. 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₀ be the whole array now.
    2. Repeat this:
       1. Subtract t by 1.
       2. Let separator B_t be such that it’s at layer t, and the (n #)M is inside it.
       3. If t = 1, then break the repeating, or else continue repeating.
    3. Find the maximum of t such that lv(A_t) < lv((n #)M).
    4. If lv(F(A_t,1)) < lv(D(F(M,1))), then
       1. Find the minimum of v such that v > t and lv(A_v) < lv(U(M)).
       2. Let string P and Q be such that B_t = “P B_v Q”.
       3. Change B_t into “P X(M) A_v Y(M) Q”.
       4. The process ends.
    5. If lv(F(A_t,1)) ≥ lv(D(F(M,1))), then
       1. Change B_t into “(n-1 #)A_t“.
       2. The process ends.

Level comparison

All arrays have the lowest and the same level. And note that the same separators (or preseparators) have the same level. To compare levels of other separators (or preseparators) A and B, we follow these steps.

1. Compare levels of the last section of A and B using normal rules. 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 –
2. 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 –
3. Let A = “#₁ (P)^p M” where M is the last section and (P)^p is the second last section, B = “#₂ (Q)^q N” where N is the last section and (Q)^q is the second last section.
4. If lv(“#₁ {P}^p“) < lv(“#₂ {Q}^q“), then lv(A) < lv(B); if lv(“#₁ {P}^p“) > lv(“#₂ {Q}^q“), then lv(A) > lv(B); if lv(“#₁ {P}^p“) = lv(“#₂ {Q}^q“), then lv(A) = lv(B).

Normal rules:

First some preparation.

1. Find the maximum of m that there’re some m-ple colons ::…: in the expressions of A or B
2. Convert all the k-ple colons of A and B into expressions of m-ple colon, using ::…: (k colons) = (2)^m+1{1 ::…:: 2} (k+1 colons)

Then the m-ple colon has the highest level, and other separators or preseparators have lower level than it.

1. Apply rule 2 to A and B until rule 2 cannot apply any more.
2. Let A = {a₁A₁a₂A₂…a_k-1A_k-1a_k}^a and B = {b₁B₁b₂B₂…b_l-1B_l-1b_l}^b
3. If a > b, then lv(A) > lv(B); if a < b, then lv(A) < lv(B); or else –
4. 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 5; if k > 1 and l > 1, follow step 6 ~ 11
5. If a₁ < b₁, then lv(A) < lv(B); if a₁ > b₁, then lv(A) > lv(B); if a₁ = b₁, then lv(A) = lv(B)
6. Let , and .
7. 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 –
8. If |M(A)| < |M(B)|, then lv(A) < lv(B); if |M(A)| > |M(B)|, then lv(A) > lv(B); or else –
9. Let A = {#₁ A_maxM(A) #₂} and B = {#₃ B_maxM(B) #₄}
10. If lv({#₂}) < lv({#₄}), then lv(A) < lv(B); if lv({#₂}) > lv({#₄}), then lv(A) > lv(B); or else –
11. If lv({#₁}) < lv({#₃}), then lv(A) < lv(B); if lv({#₁}) > lv({#₃}), then lv(A) > lv(B); if lv({#₁}) = lv({#₃}), then lv(A) = lv(B)

Subfunctions

For a separator A, U(A), D(A), X(A) and Y(A) are determined as follows. Start the subprocess shown below. Process start from the first entry of A. Note that case B1 and B3 give definitions but case A and B2 don’t.

• 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 separator (1)^mM is immediately before you, then
    1. Let string P and Q be such that A = “P (1)^mM n Q”.
    2. Define  D(A) = “P (1)^m-1M 2 (1)^mM n-1 Q”, X(A) = “P” and Y(A) = “2 (1)^m-1M 2 (1)^mM n-1 Q”.
  • Case B2: If a separator K not the colon is immediately before you, then
    1. Change the “K n” into “K 2 K n-1”.
    2. Jump to the first entry of the former K.
  • Case B3: If the “(” is immediately before you, then
    1. Let string P and Q be such that A = “P (n #)M 2 Q”, where (n #)M is the separator.
    2. Define U(A) = “(n #)M”, D(A) = “P Q”, X(A) = “P” and Y(A) = “2 Q”.

Explanation

The F(A,n) function takes the n-th section of A, and convert it into separator or preseparator. We can see “level of droppers” as level of (pre)separator it’s converted to. So case B3 in the main process means that we search for the first section with lower level than the (1)^m (we skip droppers with higher level than (1)^m), and everything between them counts in the “S_b“.

Step 2 of case B3 is special and new here. The main purpose of it is similar to the “simplifying rules” in mEAN. When we meet a dropper even lower-leveled than (1)^m-1, we insert a dropper immediately before it, so that we must meet a dropper at least (1)^m-1 the next time we start the process. For example, {1(2)³{1 ::: 2}3} reduces to (1)³{1(2)³{1 ::: 2}3}, which reduces to (1)³(1(2)³{1(2)³{1 ::: 2}3}2)²{1(2)³{1 ::: 2}3}. It seems complicated, but we have D({1(2)³{1(2)³{1 ::: 2}3}2}²) = {1}² for the 2nd section.

The process doesn’t tell us how to deal with multiple colons (i.e. the ::…:), but it doesn’t matter because the m-ple colon ::…: is just a shorthand for (2)^m+1{1 ::…:: 2} where there’re m+1 colons, so it’s case B6.

And the level comparisons use the same trick as DAN – the “preparation”.