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

Prev: Multiple dropper-expanding notation    Next: Higher-order dropper-expanding notation

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

Second-order dropper-expanding notation (soDEN) is the eleventh part of my array notation. Here primary dropping array notation, dropping array notation, nested dropper array notation and dropper-expanding notation on the plus sign come, so it make another dropper-expanding notation, which I call it a “second-order” one.

Let +2 be the 2-separator on the plus sign. It means that {1 +2 1} = {1} = the comma, {1 +2 2} is the plus sign, {1 +2 3} is the double plus sign, and so on, {1 +2 m} is the (m-1)-ple plus sign. Generally, the {1 +2 … 1 +2 1 +2 n #} works as the plus sign on {1 +2 … 1 +2 1 +2 n-1 #}.

And more, +3 is the 3-separator on the plus sign, +4 is the 4-separator on the plus sign, and so on. The U, D, X and Y function on them work the same as on normal m-separators.

Symbol – is called minus sign, with ASCII = 45.
Symbol ⊕ is called oplus, with unicode = 8853 and LaTeX = \oplus.

We can make another type of droppers now – the (m 2) – where the “2” is at the superscript position of the “)” (the minus sign here is a separator. To avoid confusing with subtraction, we always write the minus sign as bold). Let △ be a high-leveled separator. Then (1 2)△ is the plus sign, (2 2)△ is the double plus sign, (3 2)△ is the triple plus sign, and so on. The (n #)M drops down the same as before, but (1  2)M works not the same as (1)M. The (1)M searches out for a lower-leveled separator and then expands to b nests (see how a normal 1-separator works), while (1  2)M searches out for a lower-leveled separator and then expands to b droppers.

In this definition the {1+} = plus sign and the (1+) works almost the same. {1+} = (1 2){1 (2 2)△ 2} and (1+)M = (1 2)(1 (2 2)△ 2)M, so they follows the same rules.

The △ is just the shorthand for {1⊕2}, and it works similar to the {1 + 2}, but not exactly the same. {1 + 2} expands to (1)(1 + 2)(1 + 2)…(1 + 2){1 + 2}, while {1⊕2} expands to (1)(1⊕2 2)(1⊕2 2)…(1⊕2 2){1⊕2}.

It seems that (1){1⊕2} is something very high-leveled, but it works just the same as the grave accent because D({1⊕2}) = {1} = the comma and (1) (not (1 2)) means a normal 1-separator. So the grave accent = (1){1⊕2} = (1){1 + 2} = (1){1 (1 2){1⊕2} 2}. In the same way, (1)(1⊕2 2){1⊕2} is the 1-separator in ( ____  2){1⊕2}, (1)(1⊕2 2){1⊕2} = (1)(1 (1 2)(1⊕2 2){1⊕2} 2 2){1⊕2} and (n)(1⊕2 2){1⊕2} = (n)(1 (1 2)(1⊕2 2){1⊕2} 2 2){1⊕2}.

Then we have {1⊕3}, {1⊕1⊕2}, etc. and separators beyond the ⊕. The {1} =⊕ and the ⊕ just searches out for a lower-leveled separator.

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:

  • 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.
  • 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) is a dropper, where k ≥ 1, mi′s are positive integers and Ai′s are separators not the minus sign.
  • A = (m1A1m2A2…mk-1Ak-1mk  2) is a dropper, where k ≥ 1, 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 ⊕ is a shorthand for {1} and the comma is a shorthand for {1}.
  2. The grave accent is a shorthand for (1){1 (1 2){1⊕2} 2}, and the m-ple comma is a shorthand for (m){1 (1 2){1⊕2} 2}.
  3. The plus sign is a shorthand for (1 2){1⊕2}, and the +m is a shorthand for (m  2){1⊕2}.
  4. A dropper made from (m1A1m2A2…mk-1Ak-1mk) is a normal dropper, or 1-dropper, and a dropper made from (m1A1m2A2…mk-1Ak-1mk  2) is a 2-dropper.

Rule 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} = {#}, (# A 1) = (#) and (# A 1  2) = (#  2)
  • 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, 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  2)M is immediately before you, then
      1. Let t be such that the (1  2)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  2)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)#, 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 the oplus is immediately before you, then
      1. Let t be such that the oplus 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(⊕).
      4. Let string P be such that At = {P} or At = (P)#, where # is the remaining sections.
      5. Change Bt into “SbAt“, where b is the iterator, S1 = “(1)”, and Si+1 = “Si(P  2)”.
      6. The process ends.
    • Case B5: If a separator K is immediately before you, and it doesn’t fit case B1 ~ B4, 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 B6: 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 B7: 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  2)M is immediately before you, then
      1. Let string P and Q be such that A = “P (1  2)M n Q”.
      2. Define U(A) = (1  2)M, D(A) = “P (1  2)M n-1 Q”, X(A) = “P” and Y(A) = “2 (1  2)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:

  1. Apply rule 2 to A and B until rule 2 cannot apply any more.
  2. If A has an oplus at the left-superscript position of rbrace and B hasn’t, then lv(A) > lv(B); if B has an oplus at the left-superscript position of rbrace and A hasn’t, then lv(A) < lv(B); or else –
  3. Let A = {a1A1a2A2…ak-1Ak-1ak} and B = {b1B1b2B2…bl-1Bl-1bl} (or A = {a1A1a2A2…ak-1Ak-1ak} and B = {b1B1b2B2…bl-1Bl-1bl})
  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 a1 < b1, then lv(A) < lv(B); if a1 > b1, then lv(A) > lv(B); if a1 = b1, then lv(A) = lv(B)
  6. 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.
  7. If lv(X) < lv(Y), then lv(A) < lv(B); if lv(X) > lv(Y), then lv(A) > lv(B); or else –
  8. 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 –
  9. Let A = {#1 X #2} with the last X, and B = {#3 Y #4} with the last Y
  10. If lv({#2}) < lv({#4}), then lv(A) < lv(B); if lv({#2}) > lv({#4}), then lv(A) > lv(B); or else –
  11. 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 rule for plus signs before correspond to case B3 now. For example, the (1+)A = (1 +2 2)A = (1 (2  2){1⊕2} 2)A. To solve it, we meet case B7 first, so (1 (2  2){1⊕2} 2)A = (1  2)(1 (2  2){1⊕2} 2)A; then case B3 applies.

Case B4 is the one for the oplus, and it’s slightly different from the rule for the plus sign: when the outside separator expands, Si+1 = “Si(P  2)”, not “Si(P)”, and that’s also how can second-order dropper-expanding notation become strong.

2 thoughts on “Second-order dropper-expansion (doesn’t work)

  1. Aarex Tiaokhiao says:

    Suggestion for new Second-Order Dropper-Expansion Notation:
    : will be (1-2){1⊕2}
    ‘: will be (1-2)(1){1⊕2}
    :’ will be (1)(1-2){1⊕2}
    :: will be (1-2)(1-2){1⊕2}
    + will be (2-2){1⊕2}
    etc.

    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