Dropping array notation

Prev: Secondary dropping array notation    Next: Nested dropper array notation

Dropping array notation (DAN) is the seventh part of my array notation.

Let’s have an overview of EAN, pDAN and sDAN. In EAN, the grave accent works as the least 1-separator, and it drops down once until the expansion. In pDAN, the double comma works as the least 2-separator, and it drops down twice until the expansion. In sDAN, the triple comma works as the least 3-separator, and it drops down 3 times until the expansion.

Continue upward, we have the least 4-separator – the quadruple comma (,,,,), the least 5-separator – the quintuple comma (,,,,,), and so on. Generally, an m-separator drops down m times until the expansion. Here comes the definition of dropping array notation.



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


  1. The comma (,) is a shorthand for {1}.
  2. The dot . = {1{1,,2}2}, the grave accent ` = {1,,2}, the double comma ,, = {1,,,2}, the triple comma ,,, = {1,,,,2}, and so on, the m-ple comma ,,…, = {1,,…,,2} with an (m+1)-ple comma inside.

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(#) 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 and B4 are terminal but case A and B3 are not. b, n, m, M, Bu′s and K are parts of the original array but j, t, u(j), v(j), i, Si, Au′s, X, Y, 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 the m-ple comma (m ≥ 2) M is immediately before you, then
      1. Change “M n” into “M 2 M n-1”, and let Bu(m+1) be the former M.
      2. Let t be such that the M is at layer t. And let B0 be the whole array now.
      3. Repeat this:
        1. Subtract t by 1.
        2. Let separator Bt be such that it’s at layer t, and the M is inside it.
        3. If t = 1, then break the repeating, or else continue repeating.
      4. Find the maximum of u(m) such that lv(Au(m)) < lv(M).
      5. If lv(Au(m)) < lv(,), then
        1. Let string P and Q be such that Bu(m) = “P Bu(m)+1 Q”.
        2. Change Bu(m) into “P {1 Au(m)+1 2} Q”.
        3. The process ends.
      6. Set j = m. Set Au(m+1) = M.
      7. Repeat this:
        1. Subtract j by 1.
        2. Find the maximum of u(j) such that lv(Au(j)) < lv(Au(j+1)).
        3. Let string X and Y be such that Bu(j+1) = “X Bu(j+2) 2 Y”.
        4. If lv(Au(j)) < lv(“X Y”), then
          1. Find the minimum of v(j) such that v(j) > u(j) and lv(Av(j)) < lv(Au(j+2)).
          2. Let string P and Q be such that Bu(j) = “P Bv(j) Q”.
          3. Change Bu(j) into “P X Av(j) 2 Y Q”.
          4. The process ends.
        5. If j = 1, then break the repeating, or else continue repeating.
      8. Let string P and Q be such that Bu(1) = “P Bu(2) Q”.
      9. Change Bu(1) into Sb, where b is the iterator, S1 is comma, and Si+1 = “P Si Q”.
      10. The process ends.
    • Case B3: If a separator K is immediately before you, and it doesn’t fit case B1 or B2, 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 B4: 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.

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.

First some preparation.

  1. Find the maximum of m that there’re some m-ple commas in the expressions of A or B.
  2. Convert all the multiple comma of A and B into expressions of m-ple comma, using ,,…, (i commas) = {1,,…,,2} (i+1 commas)

Then the m-ple comma has the highest level, 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. 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))\}}.
  6. 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 –
  7. If |M(A)| < |M(B)|, then lv(A) < lv(B); if |M(A)| > |M(B)|, then lv(A) > lv(B); or else –
  8. Let A = {#1 AmaxM(A) #2} and B = {#3 BmaxM(B) #4}
  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)


The At in case B3 and the Bt in step 1 ~ 3 of case B2 are preparation. Step 4 and 5 are where the m-ple comma (the least m-separator) drops down to an (m-1)-separator. Step 7 is where the (m-1)-separator drops down m-1 times, to a 0-separator, and step 6 is a preparation for it. And step 8 ~ 10 are the expansion. Here, the Au(m+1) = M is an m-separator, and the Au(j) is a (j-1)-separator.

The step 5 and step 7d are where the adding rules apply. Once an adding rule apply, the expansion doesn’t apply; only when all the adding rules don’t apply, the expansion applies.

The level comparison rules also change. The preparation step change A and B into such that the m-ple comma is the only “basic separator”.

One thought on “Dropping array notation

  1. Aarex Tiaokhiao says:

    ,, corresponds to M.
    ,,, corresponds to K.
    ,,,, corresponds to Pi^1_2.
    So the limit ordinal is psi(Pi^1_w).



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