Higher-order dropper-expansion (doesn’t work)

Prev: Second-order dropper-expanding notation

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

Higher-order dropper-expanding notation (hoDEN) is the twelfth part of my array notation. Here I define higher droppers (with “- n”) then bring a notation on that.

Now let’s have an overview on EAN, DAN, DEN and soDEN. Let {+_1^1} = the grave accent, and {+_2^1} = the double comma, {+_3^1} = the triple comma, and so on. Let {+_1^2} = the plus sign, so {+_m^1=(m)\{1+_1^22\}}. Then {+_2^2=+_2,\ +_3^2=+_3}, and so on. Let {+_1^3=\oplus}, so {+_m^2=(m\text{ - }2)\{1+_1^32\}}.

We can also define m-separators on the oplus – they’re {+_m^3}. Let {+_1^4} be a high leveled separator, and {+_m^3=(m\text{ - }3)\{1+_1^42\}}, where (m 3) are 3-droppers. 3-droppers works similar to 2-droppers, except (1  3)A, the least 3-dropper. When (1  3)A reduces, all of {1 (1  3)A n}, (1 (1  3)A n) and (1 (1  3)A n  2) will expand to b-1 (1 (1  3)A n  2)′s.

Then {+_m^4} are m-separators on the {+_1^4}. Let {+_1^5} be a high leveled separator, and {+_m^4=(m\text{ - }4)\{1+_1^52\}}, where (m  4) are 4-droppers. The least 4-dropper, (1  4) works as follows: when (1  4)A reduces, all of {1 (1  3)A n}, (1 (1  3)A n), (1 (1  3)A n  2) and (1 (1  3)A n  3) will expand to b-1 (1 (1  3)A n  3)′s.

And so on, we can have {+_m^k} separators and k-droppers. The (1  m) works as follows: when (1  m)A reduces, all the {1 (1  m)A n} and (1 (1  m)A n  k) (k < m) expand to b-1 (1 (1  m)A n  m-1)′s. (The bold minus is the minus separator, and the normal-font minus is subtraction)

Definition

Syntax: s(m1A1m2A2…mk-1Ak-1mk) where mi′s are positive integers and Ai′s are separators not the minus sign.

Definition of separators:

  • {+_1^m} are separators.
  • A = {m1A1m2A2…mk-1Ak-1mk} is a separator, where k ≥ 1, mi′s are positive integers and Ai′s are separators not the minus sign.
  • If A is a dropper and B is a separator, then AB is a separator.

Definition of droppers:

  • A = (m1A1m2A2…mk-1Ak-1mk  m) is a dropper, where k ≥ 1, m and mi′s are positive integers and Ai′s are separators not the minus sign.
  • If A and B are droppers, then AB is a dropper.

Note:

  1. The comma is a shorthand for {1}.
  2. The {+_n^m} is a shorthand for (n m){\{1+_1^{m+1}2\}}. Especially, {+_1^m=(1\text{ - } m)\{1+_1^{m+1}2\}}.
  3. The grave accent is {+_1^1}, and the m-ple comma is {+_m^1}.

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} = {#}, (# 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, k, 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 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(At) < lv(D(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(At) ≥ lv(D(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 (1  m)M (where m > 1) is immediately before you, then
      1. Let t be such that the (1  m)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 plus sign 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)M).
      4. If lv(At) < lv(D(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(At) ≥ lv(D(M)), then
        1. Let string P be such that At = {P} or At = (P  k)#, where # is the remaining sections.
        2. Change Bt into “SbAt“, where b is the iterator, S1 = “(1)”, and Si+1 = “Si(P  m-1)”.
        3. The process ends.
    • Case B4: If a separator K is immediately before you, and it doesn’t fit case B1 ~ 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(At) < lv(D(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(At) ≥ lv(D(M)), then
        1. Change Bt into “(n-1 #)At“.
        2. The process ends.

Subfunctions

For 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 (1  m)M is immediately before you, then
      1. Let string P and Q be such that A = “P (1  m)M n Q”.
      2. Define U(A) = (1  m)M, D(A) = “P (1  m)M n-1 Q”, X(A) = “P” and Y(A) = “2 (1  m)M 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”.

Levels

All arrays have the lowest and the same level. The minus sign has the 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.

  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 = “#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.
  4. 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).

Normal rules:

First some preparation.

  1. Find the maximum of m that there’re some {+_1^m} in the expressions of A or B
  2. Convert all the {+_1^k} of A and B into expressions of {+_1^m}, using {+_1^i=(1\text{ - } i)\{1+_1^{i+1}2\}}

Then the {+_1^m} has the second highest level (only lower than the minus sign), and other separators have level lower than it.

  1. Apply rule 2 to A and B until rule 2 cannot apply any more.
  2. Let A = {a1A1a2A2…ak-1Ak-1ak} and B = {b1B1b2B2…bl-1Bl-1bl}
  3. 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
  4. If a1 < b1, then lv(A) < lv(B); if a1 > b1, then lv(A) > lv(B); if a1 = b1, then lv(A) = lv(B)
  5. Find out separators among A1, A2, …, Ak-1 such that they have the maximum level. i.e. find out all the X’s such that {X\in \{A_1,A_2,\cdots,A_{k-1}\}\land lv(X)\ge lv(A_1)\land lv(X)\ge lv(A_2)\land\cdots\land lv(X)\ge lv(A_{k-1})}. Note that the X’s can be different separators. And find out all the Y’s for B in the same way.
  6. If lv(X) < lv(Y), then lv(A) < lv(B); if lv(X) > lv(Y), then lv(A) > lv(B); or else –
  7. If the amount of X is less than the amount of Y, then lv(A) < lv(B); if the amount of X is more than the amount of Y, then lv(A) > lv(B); or else –
  8. Let A = {#1 X #2} with the last X, and B = {#3 Y #4} with the last Y
  9. If lv({#2}) < lv({#4}), then lv(A) < lv(B); if lv({#2}) > lv({#4}), then lv(A) > lv(B); or else –
  10. 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)

Explanation

The step 5 of case B3 means that, the “expanding part” of dropper-expansion is (P  m-1), regardless of the original k in (P  k) or the {P}.

The hoDEN up to the oplus is the same as soDEN. But some rules are slightly different.

The main process doesn’t define what to do when we meet a single {+_1^m}. Note that {+_1^m=(1\text{ - }m)\{1+_1^{m+1}2\}}, so it can be solved in case B2 (m = 1) or case B3 (m > 1).

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

Advertisements

4 thoughts on “Higher-order dropper-expansion (doesn’t work)

  1. Aarex Tiaokhiao says:

    Ideas for new hoDEN:

    ⊕ will be (1-3){1:_(3)2}
    ⊕’ will be (1)(1-3){1:_(3)2}
    ⊕: will be (1-2)(1-3){1:_(3)2}
    ⊕⊕ will be (1-3)(1-3){1:_(3)2}
    :_3 will be (1-4){1:_(4)2}
    :_4 will be (1-5){1:_(5)2}
    etc.

    :_N will be (1-N){1⊖2} and sDEN will begin at (1-1,2){1⊖2}.

    Like

    • Recently I’ve found something wrong (some expressions cause infinity loop) at NDAN, so NDAN, DEN, mDEN, soDEN and hoDEN are all ill-defined, and it takes me some time to fix this problem.

      After that, I think I can continue extensions.

      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