**Prev:** Weak dropper-multiexpanding notation

Primary dropper-dropping notation (pDDN) is the 12th part of my array notation. In this part, you probably don’t know what “dropper dropping” means, but it’ll be explained in next several parts.

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

Here I introduce a very high-leveled separator – the plus sign. To avoid confusing between this separator and addition, we also write it as {1^{+}}. Here’s how WDmEN can be embedded into pDDN. The dropper (1)^{2} in WDmEN is (1 {1^{+}} 2), (1)^{3} is (1 {1^{+}} 3), and so on. Generally, dropper (A)^{n} is (A {1^{+}} n).

# 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.
- {#Am} is a separator, where m is a positive integer, A is a separator, and # is a string such that it’s not ended with a plus sign, and {#} is a separator.
- {#
^{+}} is a separator, where # is a string such that it’s not ended with a plus sign, and {#} 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:

- The comma is a shorthand for {1}, the plus sign is a shorthand for {1
^{+}}. - The dropper for an n-separator is (n), the dropper for the colon is (1 {1
^{+}} 2), the dropper for the double colon is (1 {1^{+}} 3), and so on.

For separator A, define F(A,n) to be the n-th sections of A, with (#) changed into {#}. Generally, if (A) is a dropper and B is a separator, then F((A)B,1) = {A} and F((A)B,n) = F(B,n-1) for n > 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} = {#} 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, B_{t}′s and K are parts of the original array but t, u, i, S_{i}, R_{i}, A_{t}′s, P and Q are not. Before we start, let A_{0} and F(A_{0},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
- Change the “1,n” into “b,n-1” where n is this non-1 entry and the b is the iterator.
- Change all the entries at base layer before them into the base.
- The process ends.

- Case B2: If a separator (1)M (where M is the remaining sections) is immediately before you, then
- Let t be such that the (1)M is are layer t. And let B
_{0}be the whole array now. - Repeat this:
- Subtract t by 1.
- Let separator B
_{t}be such that it’s at layer t, and the (1)M is inside it. - If t = 1, then break the repeating, or else continue repeating.

- Find the maximum of t such that lv(A
_{t}) < lv((1)M). - If lv(F(A
_{t},1)) < lv(D(F(M,1))), then- Find the minimum of v such that v > t and lv(A
_{v}) < lv(U(M)). - Let string P and Q be such that B
_{t}= “P B_{v}Q”. - Change B
_{t}into “P X(M) A_{v}Y(M) Q”. - The process ends.

- Find the minimum of v such that v > t and lv(A
- If lv(F(A
_{t},1)) ≥ lv(D(F(M,1))), then- Let string P and Q be such that B
_{t}= “P (1)M n Q”. - Change B
_{t}into S_{b}, where b is the iterator, S_{1}is comma, and S_{i+1}= “P S_{i}2 (1)M n-1 Q”. - The process ends.

- Let string P and Q be such that B

- Let t be such that the (1)M is are layer t. And let B
- Case B3: If the plus sign (i.e. {1
^{+}}) is immediately before you, then- Let t be such that the plus sign is are layer t. And let B
_{0}be the whole array now. - Repeat this:
- Subtract t by 1.
- Let separator B
_{t}be such that it’s at layer t, and the plus sign is inside it. - If t = 1, then break the repeating, or else continue repeating.

- Find the maximum of u such that lv(A
_{u}) < lv(+). - Find the minimum of t such that lv(F(A
_{u},t)) < lv(F(A_{u},1)). If there’s no such t, jump to step 5a. - If lv(F(A
_{u},t)) < lv(D(F(A_{u},1))), then- Let string P and Q be such that P is the first t-1 sections of A
_{u}, and A_{u}= “P Q”. - Change the B
_{u}into “P X(F(A_{u},1)) A_{u}′ Y(F(A_{u},1)) Q”, where A_{u}′ is A_{u}with the first entry increased by 1. - For sections of the “P X(F(A
_{u},1)) A_{u}′ Y(F(A_{u},1)) Q”, if it’s not the last one, convert “{#}” into “(#)”; if it’s the last one, convert “(#)” into “{#}”. - The process ends.

- Let string P and Q be such that P is the first t-1 sections of A
- If lv(F(A
_{u},t)) ≥ lv(D(F(A_{u},1))), then- Let string Q be such that A
_{u}= “P Q”, where P is the first section of A_{u}. - Change the B
_{u}into “S_{b}Q”, where b is the iterator, S_{1}is “(1)” and S_{i+1}= “S_{i}R_{t}“, where R_{1}is empty string and R_{i+1}= “R_{i}F(A_{u},i+1)”. - For sections of the “S
_{b}Q”, if it’s not the last one, convert “{#}” into “(#)”; if it’s the last one, convert “(#)” into “{#}”. - The process ends.

- Let string Q be such that A

- Let t be such that the plus sign is are layer t. And let B
- Case B4: If a separator K is immediately before you, and it doesn’t fit case B1, B2 or B3, then
- Change the “K n” into “K 2 K n-1”.
- Set separator A
_{t}= K, here K is at layer t. - Jump to the first entry of the former K.

- Case B5: If an lbrace is immediately before you, then
- Change separator {n #} into string S
_{b}, where b is the iterator, S_{1}= “{n-1 #}” and S_{i+1}= “S_{i}1 {n-1 #}”. - The process ends.

- Change separator {n #} into string S
- Case B6: If a “(” is immediately before you, then
- 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
_{0}be the whole array now. - Repeat this:
- Subtract t by 1.
- Let separator B
_{t}be such that it’s at layer t, and the (n #)M is inside it. - If t = 1, then break the repeating, or else continue repeating.

- Find the maximum of t such that lv(A
_{t}) < lv((n #)M). - If lv(F(A
_{t},1)) < lv(D(F(M,1))), then- Find the minimum of v such that v > t and lv(A
_{v}) < lv(U(M)). - Let string P and Q be such that B
_{t}= “P B_{v}Q”. - Change B
_{t}into “P X(M) A_{v}Y(M) Q”. - The process ends.

- Find the minimum of v such that v > t and lv(A
- If lv(F(A
_{t},1)) ≥ lv(D(F(M,1))), then- Change B
_{t}into “(n-1 #)A_{t}“. - The process ends.

- Change B

- 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

- Case B1: If the comma is immediately before you, then

## 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.

- Compare levels of the last section of A and B using
. 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 –*normal rules* - 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 –
- 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. - 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:

- Apply rule 2 to A and B until rule 2 cannot apply any more.
- 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 –
- Let A = {a
_{1}A_{1}a_{2}A_{2}…a_{k-1}A_{k-1}a_{k}} and B = {b_{1}B_{1}b_{2}B_{2}…b_{l-1}B_{l-1}b_{l}} (or A = {a_{1}A_{1}a_{2}A_{2}…a_{k-1}A_{k-1}a_{k}^{+}} and B = {b_{1}B_{1}b_{2}B_{2}…b_{l-1}B_{l-1}b_{l}^{+}}) - 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
- If a
_{1}< b_{1}, then lv(A) < lv(B); if a_{1}> b_{1}, then lv(A) > lv(B); if a_{1}= b_{1}, then lv(A) = lv(B) - Let , and .
- 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 – - If |M(A)| < |M(B)|, then lv(A) < lv(B); if |M(A)| > |M(B)|, then lv(A) > lv(B); or else –
- Let A = {#
_{1}A_{maxM(A)}#_{2}} and B = {#_{3}B_{maxM(B)}#_{4}} - If lv({#
_{2}}) < lv({#_{4}}), then lv(A) < lv(B); if lv({#_{2}}) > lv({#_{4}}), then lv(A) > lv(B); or else – - 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 or dropper 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 (i.e. {1
^{+}}) is immediately before you, then- Let string P and Q be such that A = “P {1
^{+}} n Q”. - Define D(A) = “P {1
^{+}} n-1 Q”, X(A) = “P” and Y(A) = “2 {1^{+}} n-1 Q”.

- Let string P and Q be such that A = “P {1
- Case B2: If a separator K not the plus sign is immediately before you, then
- Change the “K n” into “K 2 K n-1”.
- Jump to the first entry of the former K.

- Case B3: If the “(” is immediately before you, then
- Let string P and Q be such that A = “P (n #)M 2 Q”, where (n #)M is the separator.
- Define U(A) = “(n #)M”, D(A) = “P Q”, X(A) = “P” and Y(A) = “2 Q”.

- Case B1: If the plus sign (i.e. {1

# Explanation

In the main process, when we meet a plus sign, first it drops down once, then we search for the leftmost section with lower level than the first section (that’s similar to WDmEN). The adding rule (step 5 of case B3) is also similar to WDmEN.

Secondary Dropper-Dropping Notation Idea:

: will be (1^;){1;2}

:: will be (1^;)(1^;){1;2}

+ will be (2^;){1;2}

++ will be (3^;){1;2}

+++ will be (4^;){1;2}

etc.

; will be weak dropper-expanding, but :s instead of `s.

LikeLike

Another probably pointless question: How are U(A), D(A), X(A) and Y(A) defined, if they start on the first entry and have no rules for lbraces on the left?

LikeLike

Yes.

LikeLike

???

LikeLike

Also, I don’t really get how you would define sections of A₀, it’s not really a separator.

LikeLike

Now it’s fixed.

LikeLike

Can you fix others and make others?

LikeLike

How would one go about evaluating, say, s(3{1⁺⁺}3)? It should be a valid array according to the Definition section. (sorry for gross misunderstandings, some of the more technical parts are lost on me)

LikeLike

We need 2 arguments at the first of an array. And only 0 or 1 plus sign at left-superscript position is allowed.

LikeLike

First one was my mistake, it should be s(3,3{1⁺⁺}3), but yeah, it should be reworded somehow. The problem:

“{m} is a separator, where m is a positive integer.” Setting m = 1, so ‘{1}’ is a separator

“{#⁺} is a separator, where # is a string such that {#} is a separator.” Setting # = ‘1’, as ‘{1}’ is a separator, so ‘{1⁺}’ is a separator

“{#⁺} is a separator, where # is a string such that {#} is a separator.” Setting # = ‘1⁺’, as ‘{1⁺}’ is a separator, so ‘{1⁺⁺}’ should by all means be a separator

LikeLike

++ isn’t defined, maybe it is in DDN.

++ -> droppers for +:::…

LikeLike

{1{2+}2} = {1{1+}1{1+}1{1+}1{1+}…}

LikeLike

Wait the comment was supposed to be a reply

I messed up

AAAAAAAAAAAAAAAAAAAAAAAAAA

LikeLike

You replied it location wrong.

LikeLike

I have the ideas that go beyond pDDN.

‘+ is the 1-separator of dropper-dropping.

+’ is the dropper-dropping separator that is greater than lv(+).

++ is the limit of sDDN and the separator of (+)-dropper-dropping.

LikeLike

Also in DDN…

We would have multiple +’s and (^+)s.

LikeLike

What {1{1+}1{1+}2} expands to? And what is the limit of pDDN?

LikeLike

~~Well, this {1{1+}1{1+}2} is illegal, since the “A_u” has only 1 section.~~In next part I’ll fix it. Wait for that.

Now it’s fixed. First we turn into step 5 of case B3, so {1{1+}1{1+}2} changes into (1{1+}1{1+}2){1{1+}1{2{1+}1{1+}2}2}. Next, we turn into step 6 of case B3, so (1{1+}1{1+}2){1{1+}1{2{1+}1{1+}2}2} changes into (1)(1{1+}1{2{1+}1{1+}2}2)(1{1+}1{2{1+}1{1+}2}2)…(1{1+}1{2{1+}1{1+}2}2){1{1+}1{2{1+}1{1+}2}2}. (1{1+}1{2{1+}1{1+}2}2) seems to be a very complicated thing, but here it’s just something 1) higher-leveled than (1{1+}1(1{1+}1…(1{1+}1(1{1+}1,2)2)…2)2) and 2) D() results (1), and the main process doesn’t run into it.

And the limit of pDDN is f(n) = s(3,3{1{1{1…{1{1,2+}2+}…2+}2+}2}2) with n “2+}”‘s.

LikeLike

How about (1{1+}1{1+}2){1{1+}2}?

LikeLike

To get {1{1+}1{1+}2}…

First, (A)^n replace into {A{1+}n}, and droppers of {1{1+}_} will be (A){1(1){1{1+}1{1+}2}2}.

However, {1(1){1{1+}1{1+}2}2} is simplified version of {1{1(1){1{1+}1{1+}2}2}2}, and the next dimensional separator after {1(1){1{1+}1{1+}2}2} is {2{1(1){1{1+}1{1+}2}2}2}.

Now, droppers of {_{1(1){1{1+}1{1+}2}2}2} is (A){1:2{1(1){1{1+}1{1+}2}2}2} (or (A){1{1{1+}2}2{1(1){1{1+}1{1+}2}2}2}), and droppers of {1{1{1+}_}2{1(1){1{1+}1{1+}2}2}2} is (1){1{1(1){1{1+}1{1+}2}2}3}. And it works like mwDEN.

We can keep climbing up the dropper levels if we let …{1(1){1{1+}1{1+}2}2}… = …{1{1(1){1{1+}1{1+}2}2}2}…

And it works like WDmEN.

And finally, the limit is {2(1){1{1+}1{1+}2}2}.

(1){1{1+}1{1+}2} will work as 1-separator, and (A){1{1+}1{1+}2} will work as A-separator.

Finally, the limit of (1){1{1+}1{1+}2}, (1)(1{1+}1{1+}2){1{1+}1{1+}2}, (1)(1{1+}1{1+}2)(1{1+}1{1+}2){1{1+}1{1+}2},… is {1{1+}1{1+}2}.

Or something like that. I don’t really know.

LikeLike

Unfortunately, {1(1){1{1+}1{1+}2}2} expands to {1{1…{1{1,2}2}…2}2}, making it as weak as {1`2}. To get the right way, use a simple {1{1+}1{1+}2} instead, and follow the process.

LikeLike

Hmmmm yes.

LikeLike

So does that mean that {1{1+}1{1+}2} expands to {1{1+}1{1{1+}1{1{1+}1{…}2}2}2}?

LikeLike

No. That’s just {1{1+}1 (1){1{1+}1{1+}2} 2}, which is lower-leveled and weaker than (1){1{1+}1{1+}2}, which is lower-leveled and weaker than (1{1+}2){1{1+}1{1+}2}, which is lower-leveled and weaker than {1{1+}1{1+}2}.

LikeLike

How about (1){1{1+}1{1+}2}?

LikeLike

It works as the 1-separator of {1{1+} ____ }.

LikeLike

Also in mWDEN…

(N^:) = (N)(1:’2).

LikeLike

Can you define the second dropper dropping separator, {2+)?

LikeLike

I know… {2+} is rows of {1+}.

LikeLike