Multiple weak dropper-expanding notation

Prev: Weak dropper-expanding notation NextWeak dropper-multiexpanding notation

Multiple weak dropper-expanding notation (mWDEN) is the tenth part of my array notation. First I introduce a notation on a higher leveled colon, then “colon and grave accents” make the multiple dropper-expanding notation.

Up to :`

Now I introduce a high-leveled separator – the colon followed by a grave accent (:`). It appears inside a { ____ :} separator. The least one is {1 :` 1:} = {1:} = the colon. But the second one, {1 :` 2:} is very strong.

The :` in {1 :` 2:} works similar to the colon, so the {1 :` 2:} expands to b nests of droppers. i.e. {1 :` 2:} becomes (1)(1 :` 2:)(1 :` 2:)…(1 :` 2:){1 :` 2:} with b-1 (1 :` 2:)′s.

The first step to reach that is (1){1 :` 2:} – the 1-separator of { ____ :} separators (we can also write it as `:). Then (2){1 :` 2:} is the 2-separator of { ____ :} separators (we can also write it as ,,:), and so on. The (1 : 2){1 :` 2:} expands to (1)(1 : 2)(1 : 2)…(1 : 2)(1 : 2){1 :` 2:} with b (1 : 2)′s, where (1)(1 : 2){1 :` 2:} is the 1-separator of ( ____ ){1 :` 2:}. Then (1 : 3){1 :` 2:}, (1 : 1 : 2){1 :` 2:}, (1 {2:} 2){1 :` 2:}, (1 {1 : 2:} 2){1 :` 2:}, (1 {1 {1 : 2:} 2:} 2){1 :` 2:}, (1 {1 (1){1 :` 2:} 2:} 2){1 :` 2:}, (1 {1 (1 {1 (1){1 :` 2:} 2:} 2){1 :` 2:} 2:} 2){1 :` 2:}, (1 (1){1 :` 2:} 2){1 :` 2:}, etc. And the limit of (1,2){1 :` 2:}, (1 (1,2){1 :` 2:} 2){1 :` 2:}, (1 (1 (1,2){1 :` 2:} 2){1 :` 2:} 2){1 :` 2:}, etc. is (1 (1)(1 (1:){1 :` 2:} 2){1 :` 2:} 2){1 :` 2:} – but what’s the (1:)?

The (1:) works fully different from (1), but very similar to the colon (i.e. {1:}). The {1:} searches out for a separator lower-leveled than it, and it expands to nested droppers. The (1:) also searches out for a dropper or separator lower-leveled than it, and it expands to nested droppers. e.g. (1:){1 :` 2:} searches out for a ( ____ ){1 :` 2:}, and the outside (#){1 :` 2:} expands to (1)(#)(#)…(#){1 :` 2:} with b (#)′s. The (1)(1 (1:){1 :` 2:} 2){1 :` 2:} is the 1-separator of ( ____ ){1 :` 2:}, the (2)(1 (1:){1 :` 2:} 2){1 :` 2:} is the 2-separator of ( ____ ){1 :` 2:}, and the (1)(1 (1:){1 :` 2:} n){1 :` 2:} is the 1-separator of ( ____ (1:){1 :` 2:} n-1){1 :` 2:}.

Then (1)(1 :` 2:){1 :` 2:} is the 1-separator of ( ____ :){1 :` 2:}, e.g. the limit of (1,2:){1 :` 2:},  (1 (1,2:){1 :` 2:} 2:){1 :` 2:}, (1 (1 (1,2:){1 :` 2:} 2:){1 :` 2:} 2:){1 :` 2:}, etc. is (1 (1)(1 :` 2:){1 :` 2:} 2:){1 :` 2:}. Finally the limit of (1){1 :` 2:}, (1)(1 :` 2:){1 :` 2:}, (1)(1 :` 2:)(1 :` 2:){1 :` 2:}, etc. is {1 :` 2:}.

Further, we have {1 :` 3:}, {1 :` 1,2:}, {1 :` 1 : 2:}, {1 :` 1 {1 :` 2:} 2:}, {1 :` 1 :` 2:}, {1 :` 1 :` 1 :` 2:}, etc. {1 :` … 1 :` 1 :` n #:} expands to (1)(1 :` … 1 :` 1 :` n #:)(1 :` … 1 :` 1 :` n #:)……(1 :` … 1 :` 1 :` n #:){1 :` … 1 :` 1 :` n #:}, and the D({1 :` … 1 :` 1 :` n #:}) results {1 :` … 1 :` 1 :` n-1 #:}.

With more grave accents

Let {1:`} = :` and we have {2:`}, {1 :` 2:`}, {1 {1 :` 2:`} 2:`}, etc. Note that { ____ :`} separators have higher level than { ____ :} separators, and { ____ :} separators have higher level than { ____ } separators.

Next, the :` ` comes. The {1 :` ` … 1 :` ` 1 :` ` n #:`} expands to (1)(1 :` ` … 1 :` ` 1 :` ` n #:`)(1 :` ` … 1 :` ` 1 :` ` n #:`)……(1 :` ` … 1 :` ` 1 :` ` n #:`){1 :` ` … 1 :` ` 1 :` ` n #:`} with b-1 (1 :` ` … 1 :` ` 1 :` ` n #:`)′s, and D({1 :` ` … 1 :` ` 1 :` ` n #:`}) results {1 :` ` … 1 :` ` 1 :` ` n-1 #:`}. To get it, we must meet (1:`), and it just works the same as the :`. e.g. (1 (1:`){1 :` ` 2:`} n:){1 :` ` 2:`} expands to (1)(1 (1:`){1 :` ` 2:`} n:)(1 (1:`){1 :` ` 2:`} n:)……(1 (1:`){1 :` ` 2:`} n:){1 :` ` 2:`} with b (1 (1:`){1 :` ` 2:`} n:)′s, and D function of it results (1 (1:`){1 :` ` 2:`} n-1:){1 :` ` 2:`}.

Continue upward, the (1:` `) works similar to {1:` `} = the :` `, and the :` ` ` inside { ____ :` `} expands to nested droppers.

Now we define another notation and another CA-value (meaning colon and grave accents). If we see {#} as {#:0}, (#) as (#:0), {#:` `…`} with m-1 colons as {#:m}, and (#:` `…`) with m-1 colons as (#:m), then {#:m} and (#:m) have CA-value m.

So the colon followed by m-1 grave accents is the least separator with CA-value m, and it searches out for a separator with CA-value = m-1. In D function, D({1:m}) = {1:m-1}.

And a separator with higher CA-value always have higher level.

Process

Note that case B1, B2, B3, B5 and B6 are terminal but case A and B4 are not. b, n, m, K, M and Bt′s are parts of the original array but t, i, Si, At′s, P and Q are not. Before we start, let A0 and F(A0) 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 B0 be the whole array now.
      2. Repeat this:
        1. Subtract t by 1.
        2. Let separator Bt 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(At) < lv((1)M).
      4. If lv(F(At)) < lv(D(F(M))), then
        1. Find the minimum of v such that v > t and lv(Av) < lv(U(M)).
        2. Let string P and Q be such that Bt = “P Bv Q”.
        3. Change Bt into “P X(M) Av Y(M) Q”.
        4. The process ends.
      5. If lv(F(At)) ≥ lv(D(F(M))), then
        1. Let string P and Q be such that Bt = “P (1)M n Q”.
        2. Change Bt into Sb, where b is the iterator, S1 is comma, and Si+1 = “P Si 2 (1)M n-1 Q”.
        3. The process ends.
    • Case B3: If a separator K, which is the {1:m} or the (1:m)M with m > 0, is immediately before you, then
      1. Let t be such that the K is are layer t. And let B0 be the whole array now.
      2. Repeat this:
        1. Subtract t by 1.
        2. Let separator Bt be such that it’s at layer t, and the K is inside it.
        3. If t = 1, then break the repeating, or else continue repeating.
      3. Find the maximum of t such that lv(At) < lv(K).
      4. If lv(F(At)) < lv(D(F(K))), then
        1. Let string P and Q be such that Bt = “P Bt+1 Q”.
        2. Change Bt into “P X(K) Av Y(K) Q”.
        3. The process ends.
      5. If lv(F(At)) ≥ lv(D(F(K))), then
        1. Let string P be such that At = {P} or At = (P)#, where # is the remaining sections.
        2. Change Bt into “SbAt“, where b is the iterator, S1 = “(1)”, and Si+1 = “Si(P)”.
        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 At = 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 Sb, where b is the iterator, S1 = “{n-1 #}” and Si+1 = “Si 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 B0 be the whole array now.
      2. Repeat this:
        1. Subtract t by 1.
        2. Let separator Bt 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(At) < lv((n #)M).
      4. If lv(F(At)) < lv(D(F(M))), then
        1. Find the minimum of v such that v > t and lv(Av) < lv(U(M)).
        2. Let string P and Q be such that Bt = “P Bv Q”.
        3. Change Bt into “P X(M) Av Y(M) Q”.
        4. The process ends.
      5. If lv(F(At)) ≥ lv(D(F(M))), then
        1. Change Bt into “(n-1 #)At“.
        2. The process ends.

Subfunctions

If separator A = {1:m}, then D(A) = {1:m-1}, X(A) = “{1” and Y(A) = “2:m-1}”.

If separator A = (1:m)M, then X(A) = “(1” and Y(A) = “2:m-1)M”.

For other 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 a separator K, which is the {1:m} or the (1:m)M, is immediately before you, then
      1. Let string P and Q be such that A = “P K n Q”.
      2. Define U(A) = K, D(A) = “P K n-1 Q”, X(A) = “P” and Y(A) = “2 K n-1 Q”.
    • Case B2: If a separator K which doesn’t fit case B1 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 change of case B3 in the process make mWDEN strong.

In step 4 of case B3, we don’t use U({1:m}), so we also don’t define U({1:m}). But actually U({1:m}) exists, which has a very high level, and it comes in the next part.

Advertisements

6 thoughts on “Multiple weak dropper-expanding notation

  1. Aarex Tiaokhiao says:

    I found the mistake for step 5 in Case B3. It will expands into (1) sections only instead of any (1^:n)s. Is this mistake should be corrected?

    Like

.

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s