Dropper-expanding notation (doesn’t work)

Prev: Nested dropper array notation    Next: Multiple dropper-expanding notation

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

Dropper-expanding notation (DEN) is the ninth part of my array notation.

Symbol + is called plus sign, with ASCII = 43.

In NDAN we say that, the plus sign (+) has the highest level, and even higher than the triangle. Here I explain what’s the “+”. The plus sign is used as a separator (to avoid confusing with addition, we usually write it as bold), {1 + 1} = {1} by rule 2, and {1 + 2} is the triangle. In NDAN, the triangle always appears as a section, a part of a separator. But in DEN, we can have a single {1 + 2}. e.g. s(a,b {1 + 2} 2) = s(a,b (1)(1 + 2)(1 + 2)…(1 + 2){1 + 2} 2) with b plus signs, and the (1 + 2) is exactly the circle.

The plus sign works as follows: when we meet a plus sign in the process, we just simply change {1 + 1 + … 1 + 1 + n #} into (1)(1 + 1 + … 1 + 1 + n #)(1 + 1 + … 1 + 1 + n #)……(1 + 1 + … 1 + 1 + n #){1 + 1 + … 1 + 1 + n #} with b-1 (1 + 1 + … 1 + 1 + n #)′s.

Something about levels. The plus sign has the highest level, so the triangle (= {1 + 2}) has lower level than it. But non-triangle separators in NDAN have no plus signs inside them, so they have lower level than {1 + 2}.

The 4 subfunctions change. For separator A, to define U(A), D(A), X(A) and Y(A), we need to start a process on A, even if A is the triangle.

Finally, let {1+} be the plus sign. So we can go further. e.g. {1 + 2+}, {1 {2+} 2+}, {1 {1 + 2+} 2+}, etc.

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.
  • {#+} is a separator, where # 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.

Note:

  1. The plus sign is a shorthand for {1+}, and the comma is a shorthand for {1}.
  2. The grave accent is (1){1 + 2}, the double comma is (2){1 + 2}, the triple comma is (3){1 + 2}, and so on.

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) = (#)
  • 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, Bt′s and K 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 plus sign is immediately before you, then
      1. Let t be such that the plus sign 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)”.
      6. 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(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.

Level comparison

All arrays have the lowest and the same 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 a plus sign at the left-superscript position of rbrace and B hasn’t, then lv(A) > lv(B); if B has a plus sign 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. Let {M(A)=\{i\in\{1,2,\cdots,k-1\}|\forall j\in\{1,2,\cdots,k-1\}(lv(A_i)\ge lv(A_j))\}}, and {M(B)=\{i\in\{1,2,\cdots,l-1\}|\forall j\in\{1,2,\cdots,l-1\}(lv(B_i)\ge lv(B_j))\}}.
  7. If lv(AmaxM(A)) < lv(BmaxM(B)), then lv(A) < lv(B); if lv(AmaxM(A)) > lv(BmaxM(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 = {#1 AmaxM(A) #2} and B = {#3 BmaxM(B) #4}
  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)

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 the plus sign is immediately before you, then
      1. Let string P and Q be such that A = “P + n Q”.
      2. Define U(A) = “+”, D(A) = “P + n-1 Q”, X(A) = “P” and Y(A) = “2 + n-1 Q”.
    • Case B2: If a separator K not the plus sign 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

All the dropping and expanding rules in DEN are the same as before, but case B3 in the process and case B1 in the subprocess make it strong.

Above {1 + 2}: there’s (1){1 + 3} – simply the 1-separator of { ____ + 2}. And then (2){1 + 3} is the 2-separator of { ____ + 2}. And further, (1,2){1 + 3}, (1 (1){1 + 2} 2){1 + 3}, (1 (1)(1 + 2){1 + 2} 2){1 + 3}, (1 (1)(1 + 2)(1 + 2){1 + 2} 2){1 + 3}, etc. these lead to (1 {1 + 2} 2){1 + 3}.

Then (1 (1){1 + 3} 2){1 + 3}, (1 (2){1 + 3} 2){1 + 3}, (1 (1,2){1 + 3} 2){1 + 3}, (1 (1 {1 + 2} 2){1 + 3} 2){1 + 3}, and so on, the limit of (1 (1,2){1 + 3} 2){1 + 3}, (1 (1 (1,2){1 + 3} 2){1 + 3} 2){1 + 3}, (1 (1 (1 (1,2){1 + 3} 2){1 + 3} 2){1 + 3} 2){1 + 3}, etc. is (1 (1)(1 + 2){1 + 3} 2){1 + 3}, where (1)(1 + 2){1 + 3} (not (1)(1 + 3){1 + 3}) is the 1-separator of ( ____ ){1 + 3}.

The limit of (1)(1 + 2){1 + 3}, (1)(1 + 2)(1 + 2){1 + 3}, (1)(1 + 2)(1 + 2)(1 + 2){1 + 3}, etc. is (1 + 2){1 + 3}. The limit of (1,2 + 2){1 + 3}, (1 (1,2 + 2){1 + 3} 2 + 2){1 + 3}, (1 (1 (1,2 + 2){1 + 3} 2 + 2){1 + 3} 2 + 2){1 + 3}, etc. is (1 (1)(1 + 3){1 + 3} 2 + 2){1 + 3}, where (1)(1 + 3){1 + 3} is the 1-separator of ( ____ + 2){1 + 3}.

And the limit of (1)(1 + 3){1 + 3}, (1)(1 + 3)(1 + 3){1 + 3}, (1)(1 + 3)(1 + 3)(1 + 3){1 + 3}, etc. is {1 + 3}. That’s what we need to get {1 + 3}.

Separator (#)(1 + 2)(1 + 2)…(1 + 2){1 + 2} always searches out for no-plus separators. Separator (#)(1 + 3)(1 + 3)…(1 + 3){1 + 3} searches out for { ____ + 2} separators, and separator (#)(1 + n)(1 + n)…(1 + n){1 + n} searches out for { ____ + n-1} separators.

In case B3 in the process, a separator {1 + 1 + … 1 + 1 + n #} expands to nested droppers, and it works on lower-leveled separators, so this notation is called “dropper-expanding” notation.

One thought on “Dropper-expanding notation (doesn’t work)

.

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