SAN

强数阵记号 (Strong Array Notation, SAN) 是 HypCos 创造的数阵记号。它在数阵记号中具有里程碑式的意义，同时其所应用的 dropping 思想也在相当长一段时间内在大数领域中起到了重要的作用。${\displaystyle }$

SAN 分为两代，第一代有 7 个部分，这几个部分分别是：

• 线性数阵 (Linear Array Notation, LAN)
• 扩展数阵 (Extended Array Notation, exAN)
• 扩张数阵 (Expanding Arrow Notation, EAN)
• 多重扩张数阵 (Multiple Expanding Array Notation, mEAN)
• 初级下降数阵 (Primary Dropping Array Notation, pDAN)
• 次级下降数阵 (Secondary Dropping Array Notation, sDAN)
• 下降数阵 (Dropping Array Notation, DAN)

第二代分为 5 个部分，然而这些部分的定义出现了流程无限循环而不能终止的情况：

• 嵌套下降子数阵 (Nested Dropper Array Notation, NDAN)
• 下降子扩张数阵 (Dropper-Expanding Notation, DEN)
• 多重下降子扩张数阵 (Multiple Dropper-Expanding Notation, mDEN)
• 二阶下降子扩张数阵 (Second-Order Dropper-Expanding Notation, soDEN)
• 高阶下降子扩张数阵 (Higher-Order Dropper-Expanding Notation, hoDEN)

于是有了第二代的第二次尝试，但是依然存在无限循环的问题：

• 嵌套下降子数阵 (Nested Dropper Array Notation, NDAN)
• 弱下降子扩张数阵 (Weak Dropper-Expanding Notation, WDEN)
• 多重弱下降子扩张数阵 (Multiple Weak Dropper-Expanding Notation, mWDEN)
• 弱下降子多重扩张数阵 (Weak Dropper-Multiexpanding Notation, WDmEN)
• 初级下降子下降数阵 (Primary Dropper-Dropping Notation, pDDN)

我们下面对这些数阵进行介绍。

线性数阵

一个线性数阵具有如下形式

\[ s(a,b,c,\dots,z) \]

其中各 \(a,b,c,\dots,z\) 均为正整数，它们称为项。s 即为强 (Strong) 的含义。表达式的第一项称为底，第二项称为迭代子。字符串 \(A\) 在 \(B\) 之前，当且仅当 \(A\) 写在 \(B\) 的左侧。\(A\) 在 \(B\) 之后，当且仅当 \(B\) 在 \(A\) 之前。字符串 \(A\) 紧接在 \(B\) 之前当且仅当 \(A\) 在 \(B\) 之前，并且不存在 \(A\) 在 \(C\) 之前且 \(C\) 在 \(B\) 之前的 \(C\)。\(A\) 紧接在 \(B\) 之后当且仅当 \(B\) 在 \(A\) 之前。

线性数阵具有如下三个规则

\[ s(a,b)=a^b \]

\[ s\left(a,b^+,c^+@\right)=s\left(a,s\left(a,b,c^+@\right),c@\right),b,c\neq1 \]

\[ s(@,1)=s(@) \]

式中 @ 为数阵的一部分，可以为空。

若以上的规则都不适用，则进入下面的流程，首先请看数阵的第3项。

情况A：若该项为1，则看向数阵的下一项。

情况B：若该项不为1，则

1. 把该项减1，把前一项改为迭代子；
2. 把前一项之前的项全改成底。

若记

\[ a[n]=\underbrace{a,a,\dots,a}_{n\text{个}a}, \]

则可以将上述流程紧凑地写为

\[ s(a,b,1[n],c,@)=s(a[n+1],b,c-1,@). \]

以上就是线性数阵的全部规则。

解释

下面对数阵进行解释。如果数阵中只有两个元素，那么

\[ s(a,b)=a^b. \]

这实际上就是指数。

如果数阵中只有三个元素，并且最后一个元素为1，那么

\[ s(a,b,1)=s(a,b)=a^b. \]

对于\(s(a,1,2)\)来说，前三条简单规则均不适用，此时我们首先看第三项。这是一个非一项，因此我们进入情况B。然后将“1,2”改为“b,2-1”=“1,1”（此处迭代子为1），且“它们之前的元素”只包含基数a，因此

\[ s(a,1,2)=s(a,1,1)=a^1=a. \]

同理，对于任意的\(c\)，都有

\[ s(a,1,c)=s(a,1,1)=a. \]

接下来有

\[ s(a,b,2)=s(a,s(a,b-1,2),1)=a^{s(a,b-1,2)}=a^{a^{s(a,b-2,2)}}=\dots=a\uparrow\uparrow b, \]

因此我们有

\[ s(a,b,2)=a\uparrow\uparrow b. \]

\[ s(a,b,3)=s(a,s(a,b-1,3),2)=a\uparrow\uparrow s(a,b-1,3)=a\uparrow\uparrow(a\uparrow\uparrow s(a,b-2,3))=a\uparrow\uparrow\uparrow b, \]

即

\[ s(a,b,3)=a\uparrow\uparrow\uparrow b. \]

因此我们得到结论

\[ s(a,b,c)=a\uparrow^c b=a\rightarrow b\rightarrow c=\{a,b,c\}, \]

对于含有四个元素的数阵，我们有

\[ s(a,b,c,1)=s(a,b,c). \]

类似地

\[ s(a,1,c,d)=s(a,1,1,d). \]

一般地有

\[ s(a,1,c,\#)=s(a,1,1,\#), \]

式中 \(\#\) 为项的一部分。

接下来考察\(s(a,b,1,2)\)。首先，我们查看第3个项——它是1，因此我们满足情况A。然后查看下一个项（第4个项）——它是2，因此我们满足情况B。将“1,2”更改为“b,1”，然后将“它们之前的项”（即前两个项）更改为底a。因此，我们得到

\[ s(a,b,1,2)=s(a,a,b,1)=s(a,a,b)=a\uparrow^b a. \]

特别地

\[ s(a,1,c,2)=s(a,1,1,2)=a^a. \]

接下来有

\[ \begin{array}{l} s(a,b,2,2)=s(a,s(a,b-1,2,2),1,2)=\dots\\ =\underbrace{s(a,s(a,\dots s(a,s(a,1,2,2),1,2)\dots,1,2),1,2)}_{b-1\text{个}1,2}\\ =\underbrace{s(a,s(a,\dots s(a,a^a,1,2)\dots,1,2),1,2)}_{b-1\text{个}1,2}. \end{array} \]

以及

\[ s(a,b,c,2)=\underbrace{s(a,s(a,\dots s(a,a^a,c-1,2)\dots,c-1,2),c-1,2)}_{b-1\text{个}c-1,2}. \]

类似地，

\[ s(a,b,1,3)=s(a,a,b,2), \]

\[ s(a,1,c,3)=s(a,1,1,3)=s(a,a,1,2)=a\uparrow^a a, \]

\[ s(a,b,1,c)=s(a,a,b,c-1), \]

\[ s(a,1,c,d)=s(a,1,1,d)=s(a,a,1,d-1)=s(a,a,a,d-2), \]

以此类推。于是我们得到

\[ s(a,b,c,d)=\underbrace{a\rightarrow a\rightarrow a\rightarrow\cdots\rightarrow a}_{d\text{个}a}\rightarrow b\rightarrow c. \]

扩展数阵

对于扩展数阵，我们给出如下的概念。

1. 形如 \(\{m_1A_1m_2A_2\ldots m_{k-1}A_{k-1}m_k\}\) 的结构称为分隔符，其中 \(m_i\) 是正整数，\(A_i\) 也是分隔符，单独的 \(\{m_i\}\) 也是一个分隔符，\(\{1\}\) 相当于逗号。
2. 有了分隔符，项就有了更一般的定义：数阵中被分隔符隔开的正整数称为项。
3. 层(layer)的递归定义如下：

1. 数阵 \(s(m_1A_1m_2A_2\ldots m_{k-1}A_{k-1}m_k)\) 中，\(m_i\) 位于底层，分隔符 \(A_i\) 位于第 1 层；
2. 位于第 \(\mathrm{k}\) 层的分隔符 \(\{m_1A_1m_2A_2\ldots m_{k-1}A_{k-1}m_k\}\) 中，分隔符 \(A_i\) 位于第 \(k+1\) 层。

更加正式的递归定义可以表述如下。

1. \(\{m\}\) 是分隔符，其中的 m 是正整数。
2. \(\{\#Am\}\) 是分隔符，其中 \(m\) 是正整数，\(A\) 是分隔符，\(\#\) 是一个字符串，其中 \(\{\#\}\) 是分隔符。

(4)排列成一串的数字被分隔符隔开的结构成为“数阵结构”，比如“1,2,3”是一个数阵结构，在 SAN 中，若 A 是一个数阵结构，那么 \(\{A\}\) 称为分隔符，\(s(A)\) 称为数阵。把单独的数字称为数阵结构，意味着它有扩展成多项的可能。

更加正式的递归定义可以表述如下。

1. \(s(a,b)\) 是一个数阵，其中 a 和 b 是正整数。
2. \(s(\#Am)\) 是一个数阵，其中 \(m\) 是一个正整数，\(A\) 是一个分隔符，\(\#\) 是一个字符串，因此 \(\mathrm{s}(\#)\) 是一个数阵。

扩展数阵具有如下的规则。规则 1：

\[ s(a,b)=a^b, \]

规则 2：

\[ s\left(a,b^+,c^+@\right)=s\left(a,s\left(a,b,c^+\#\right),c\#\right),b,c\neq1, \]

规则 3a：

\[ s(@A1)=s(@), \]

规则 3b：

\[ \{@A1\}=\{@\}, \]

规则 4：

\[ \{\circledast_1\mathrm{A}1\mathrm{B}@2\}=\{\circledast_1\mathrm{B}@2\},\text{其中}\mathrm{lv}(\mathrm{A})<\mathrm{lv}(\mathrm{B}). \]

若以上的规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。

流程开始。

情况 A：如果该项是 1，则看数阵的下一项；

情况 B：如果该项不是 1，则看该项的左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符不是一个逗号，则：

1. 记该分隔符为 A，记该项为 n，则此处的符号形如“A n”；
2. 把“A n”改写为“A 2 A n-1”；
3. 将目光投向“A 2 A n-1”中第一个“A”中的第一项，回到流程开始处。

情况 B3：如果紧跟在该项之前的东西不是一个分隔符，而是一个“{”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如“\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 把“\(\{n@\}\)”改写为 \(S_0\)，其中字符串函数 \(S_1=“\{n-1@\}”\)，\(S_{i+1}=“S_11\{n-1@\}”\)；
3. 流程结束。

规则 1 和 2 以及情况 A 与 LAN 中的规则相同。规则 B1 略有不同，但规则 3b 和 4、情况 B2 和 B3 均为新规则。规则 5 此时并非必需，但它使 exAN 与后续部分保持一致。

我们在前文中使用了 \(\mathrm{lv}(A)\)，它代表分隔符的级别。级别是分隔符（实际上数阵也有级别）的一个属性，可以使用“<”、“>”和“=”与其他分隔符进行比较。其定义如下。A 的级别由 \(\mathrm{lv}(A)\) 给出。

首先，所有数阵都具有相同的最低级别。注意，相同的分隔符具有相同的级别。要比较其他分隔符 A 和 B 的级别，我们可以遵循以下步骤。

1.对两者重复应用裁尾规则，直到不能再应用； 2.令

\[ A=\left\{a_1A_1a_2A_2\dots A_{k-1}a_k\right\}, \]

\[ B=\left\{b_1B_1b_2B_2\dots B_{l-1}b_l\right\}, \]

3.若 \(k=1,l>1\)，则 \(\operatorname{lv}(A)<\operatorname{lv}(B)\)；若 \(k>1,l=1\)，则 \(\operatorname{lv}(A)>\operatorname{lv}(B)\)；若 \(k=l=1\)，则按照第四步进行；若 \(k>1,l>1\)，则按照 5-10 步进行。 4.若 \(a_1<b_1\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)；若 \(a_1>b_1\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)；若 \(a_1=b_1\)，则 \(\mathrm{lv}(A)=\mathrm{lv}(B)\)。 5.令

\[ M(A)=\left\{i\mid\forall j\left(\mathrm{lv}\left(A_i\right)\ge\mathrm{lv}\left(A_j\right)\right)\right\}, \]

\[ M(B)=\{i\mid\forall j(\mathrm{lv}(B_i)\ge\mathrm{lv}(B_j))\}. \]

6.若 \(\mathrm{lv}\left(A_{\max M(A)}\right)\neq\mathrm{lv}\left(B_{\max M(B)}\right)\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}\left(A_{\max M(A)}\right),\mathrm{lv}\left(B_{\max M(B)}\right)\) 的序关系相同，否则进入下一步。 7.若 \(|M(A)|<|M(B)|\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)；若 \(|M(A)|>|M(B)|\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)；否则进入下一步。 8.令 \(A=\{\#_1A_{\max\mathrm{M}(A)}\#_2\}\) 且 \(B=\{\#_3B\max\mathrm{M}(B)\#_4\}\)。 9.如果 \(\mathrm{lv}(\{\#_2\})<\mathrm{lv}(\{\#_4\})\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)；如果 \(\mathrm{lv}(\{\#_2\})>\mathrm{lv}(\{\#_4\})\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)；否则进入下一步。 10.如果 \(\mathrm{lv}(\{\#_1\})<\mathrm{lv}(\{\#_3\})\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)；如果 \(\mathrm{lv}(\{\#_1\})>\mathrm{lv}(\{\#_3\})\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)；若 \(\mathrm{lv}(\{\#_1\})=\mathrm{lv}(\{\#_3\})\)，则 \(\mathrm{lv}(A)=\mathrm{lv}(B)\)。

解释

在 exAN 中，维度数阵是指分隔符最多为 \(\{n\}\) 的数阵。规则 B2 和 B3 展示了它们的强大之处。

\(s(a,b\{2\}2)\) 是最简单的维度数阵。为了求解它，我们需要使用以下过程。第三个元素是 2，并且 2 之前紧接着一个分隔符 \(\{2\}\)（不是逗号），因此我们满足情况 \(B2\)。现在将数阵更改为 \(s(a,b\{2\}2\{2\}1)\)，然后从前一个 \(\{2\}\) 中的第一个元素重新开始该过程。结果是 2 而不是 1，并且 2 之前紧接着一个大括号，因此我们满足情况 B3。现在将 \(\{2\}\) 变为

\(\{1\}1\{1\}1\ldots\{1\}1\{1\}\)，其中有 b 个 \(\{1\}\)，因此

\[ \begin{array}{l} s(a,b\{2\}2)=s(a,b\underbrace{\{1\}1\{1\}1\dots\{1\}1\{1\}2\{2\}1}_{b\text{个}1})\\ =s(a,b\underbrace{1,1\dots,1,2}_{b-1\text{个}1})\\ =s\left(\underbrace{a,a,a,a\dots,a,a}_{b\text{个}a},b\right). \end{array} \]

与 BEAF 和 BAN 不同，在此数阵表示法中，\(s(a,b\{2\}2)\)、\(s(a,b,1\{2\}2)\) 和 \(s(a,b,1,1\{2\}2)\) 并不相同。它们分别是

\[ s(a,b\{2\}2)=s(a,b\underbrace{1,1\dots,1,2}_{b-1\text{个}1}), \]

\[ s(a,b,1\{2\}2)=s(a,b\underbrace{1,1\dots,1,2}_{b\text{个}1}), \]

\[ s(a,b,1,1\{2\}2)=s(a,b\underbrace{1,1\dots,1,2}_{b+1\text{个}1}). \]

我们有

\[ s(a,b,\{2\}3)=s(a,b\underbrace{1,1\dots,1}_{b-1\text{个}1},2,\{2\}2). \]

如果将其化为

\[ s(a,b^{\prime},\underbrace{1,1\dots,1}_{b-1\text{个}1},1,\{2\}2), \]

则它将表示为

\[ s\left(a,b^{\prime}\underbrace{1,1\dots,1}_{b^{\prime}+b-1\text{个}1},1,2\right). \]

在大多数情况下，b 与 b'相比微不足道，因此剩余的元素 \((s(a,b,1,1\ldots,1,1\{2\}2)\) 中剩余的 b 个 1）不会影响记号的强度。

下面是一些例子

\[ \begin{array}{l} s(a,b\{2\}1\{2\}2)=s(a,b\{2\}\underbrace{1,1,\dots,1}_{b-1\text{个}1},2)\\ =s(a,a\{2\}\underbrace{a,a,\dots,a}_{b-2\text{个}a},b), \end{array} \]

\[ s(a,b\{2\}1\{2\}c)=s(a,b\{2\}\underbrace{1,1,\dots,1}_{b-1\text{个}1},c-1), \]

\[ s(a,b\{c\}d)=s(a,b\underbrace{\{c-1\}1\{c-1\}1\dots\{c-1\}1\{c-1\}}_{b-1\text{个}\{c-1\}}2\{c\}d-1). \]

规则 3b 和情况 B1 可以让我们可以更进一步。

例如，为了求解 \(s(a,b\{1,2\}2)\)，我们启动该过程，并满足情况 B2，此时数阵变为 \(s(a,b\{1,2\}2\{1,2\}1)\)。然后，我们从之前的 \(\{1,2\}\) 中的 1 重新开始该过程，并满足情况 B1，因此将 1,2 更改为 \(b,1\)，并将基础层的项更改为 \(a\)。因此 \(s(a,b\{1,2\}2)=s(a,a\{b,1\}2\{1,2\}1)\)。现在规则 3a 适用，因此 \(s(a,a\{b,1\}2\{1,2\}1)=s(a,a\{b,1\}2)\)，然后规则 3b 适用，因此 \(s(a,a\{b,1\}2)=s(a,a\{b\}2)\)。因此，一个分隔符内可以包含多个项。

为了求解 \(s(a,b\{1\{2\}1,2\}2)\)，我们先按照上述流程，然后满足情况 B2，再满足情况 B1。在情况 B1 适用之前，数阵为 \(s(a,b\{1\{2\}1,2\}2\{1\{2\}1,2\}1)\)；在情况 B1 适用之后，数阵变为 \(s(a,a\{1\{2\}b,1\}2\{1\{2\}1,2\}1)\)。然后规则 3a 和 3b 适用，因此 \(s(a,b\{1\{2\}1,2\}2)=s(a,a\{1\{2\}b\}2)\)。如果我们使用线性数阵符号中的 B1 情况会怎样？\(s(a,b\{1\{2\}1,2\}2)\) 将会是 \(s(a,a\{a\{a\}b\}2)\)。当 \(a\ge3\) 且 \(b\ge2\) 时，它将再次简化为包含 \(\{1\{2\}1,2\}\) 的内容——它永远无法解决。因此，有必要对情况 B1 进行修改。

对于 \(n\) 个用分隔符隔开的同一项 \(a\)，可以用一个字符串函数来表达：\(a[n]=aA_1aA_2\ldots A_{n-1}a\)（共 \(n\) 个 \(a\)），并且规定 \(a[0]\) 为空字符串（更确切地说是不存在的项，因为需要把它附近的某些符号一并移除，比如 \(s(a,b,d[0],c)=s(a,b,c)\)，相邻的逗号被移除了），\(a[1]=“a”\)，这样流程就可以改写成具有一定普适性的规则：

1. \(s(a,b,1[n],1,c@)=s(a[n+2],b,c-1@)\)，同线性数阵，注意分隔符保持原样。
2. \(s(a,b,1[n],1\text{ A c@})=s(a,b,1[n],1\text{ A }2\text{ A }c-1@)\)，接着对第一个 A 操作：如果 \(A\) 形如 \(\{d@\}\) 且 \(d>1\)，其中 \(\#\) 表示任意字符串，则把 A 拆成“\(\{d-1@\}1\{d-1@\}1\dots\{d-1@\}\)”（共 \(b\) 个 \(\{d-1\#\}\)）。

如果 A 形如 \(\{1\#\}\)，其中 # 表示任意的字符串，那么就像线性数阵一样操作 A 中的数阵，只不过其中底和迭代子用的是整个数阵的底和迭代子。观察线性数阵的“规则”\(s(a,b,1[n],c@)=s(a[n+1],b,c-1@)\)，可以发现这将 c 减去 1，将 c 的前一项改为迭代子，将 c 的前一项之前的数字改成底。不同的是，操作分隔符中的数阵结构，改写为底的对象仅限于“c 的前一项之前且在底的项”。

扩张数阵

扩张数阵的第一部分引入了点号作为括号级次的推广。其原理如下：当我们在点之后立即遇到非 1 的元素时，首先像 exAN 中的 B2 那样将点拉出，然后将前一个点变为 \(\{1\{1\ldots\{1\{1,2\}2\}\ldots2\}2\}\)，其中有 \(b-1\) 个 1，\(b\) 是迭代子。例如我们有

\[ \begin{array}{l} s(a,b.2)=s(a,b\underbrace{\{1\{1\dots\{1\{1,2\}2\}\dots2\}2\}2}_{b\text{个}2}.1)\\ =s(a,b\underbrace{\{1\{1\dots\{1\{1,2\}2\}\dots2\}2\}2}_{b\text{个}2}), \end{array} \]

\[ s(a,b.c\#)=s(a,b\underbrace{\{1\{1\dots\{1\{1,2\}2\}\dots2\}2\}2}_{b\text{个}2}.c-1\#), \]

\[ s(a,b.1.2)=s(a,b.1\underbrace{\{1\{1\dots\{1\{1,2\}2\}\dots2\}2\}2}_{b\text{个}2}). \]

现在出现了一种新的分隔符。第一个是 \(\{1^{\cdot}\}\)，其中的点位于右括号的左上标位置。于是我们有

\[ \{2^{\cdot}\},\{3^{\cdot}\},\{1,2^{\cdot}\},\{1\{1,2\}2^{\cdot}\},\{1\{1^{\cdot}\}2^{\cdot}\}, \]

\[ \{2\{1^{\cdot}\}2^{\cdot}\},\{1\{1,2\}2\{1^{\cdot}\}2^{\cdot}\},\{1\{1^{\cdot}\}3^{\cdot}\}, \]

\[ \{1\{1^{\cdot}\}1\{1^{\cdot}\}2^{\cdot}\},\{1\{2^{\cdot}\}2^{\cdot}\},\{1\{3^{\cdot}\}2^{\cdot}\}, \]

\[ \{1\{1,2^{\cdot}\}2^{\cdot}\},\{1\{1\{1,2^{\cdot}\}2^{\cdot}\}2^{\cdot}\}, \]

以此类推。它们可以使用 exAN 流程和“点规则”来解决。

\(\{1^{\cdot2}\}\) 的操作如下：当我们在 \(\{1^{\cdot2}\}\) 之后立即遇到非 1 项时，首先像 exAN 中的 B2 情况那样将其拉出，然后将之前的 \(\{1^{\cdot2}\}\) 更改为 \(\{1\{1\ldots\{1\{1,2\cdot\}2\cdot\}\ldots2\cdot\}2\cdot\}\)，其中有 \(b-1\) 个 1，\(b\) 是迭代子。于是我们有

\[ \{2^{\cdot2}\},\{1,2^{\cdot2}\},\{1\{1^{\cdot}\}2^{\cdot2}\},\{1\{2^{\cdot}\}2^{\cdot2}\},\{1\{1,2^{\cdot}\}2^{\cdot2}\}, \]

\[ \{1\{1\{1^{\cdot}\}2^{\cdot}\}2^{\cdot2}\},\{1\{1\{1\{1^{\cdot}\}2^{\cdot}\}2^{\cdot}\}2^{\cdot2}\},\{1\{1^{\cdot2}\}2^{\cdot2}\}, \]

\[ \{1\{1\{1^{\cdot}\}2^{\cdot}\}2\{1^{\cdot^2}\}2^{\cdot^2}\},\{1\{1^{\cdot^2}\}3^{\cdot^2}\},\{1\{1^{\cdot^2}\}1\{1^{\cdot^2}\}2^{\cdot^2}\}, \]

\[ \{1\{2^{\cdot2}\}2^{\cdot2}\},\{1\{1,2^{\cdot2}\}2^{\cdot2}\},\{1\{1\{1^{\cdot}\}2^{\cdot2}\}2^{\cdot2}\}, \]

\[ \{1\{1\{1^{\cdot2}\}2^{\cdot2}\}2^{\cdot2}\},\{1\{1\{1\{1^{\cdot2}\}2^{\cdot2}\}2^{\cdot2}\}2^{\cdot2}\}, \]

以此类推。

类似地还有 \(\{1^{-3}\}\)，\(\{1^{-4}\}\) 等。当我们在 \(\{1^{k}\}\) 之后立即遇到非 1 的元素时，首先像 exAN 中的 \(B2\) 那样将其取出，然后将之前的 \(\{1^{-k}\}\) 更改为 \(\{1\{1\ldots\{1\{1,2^{-k-1}\}2^{-k-1}\}\ldots2^{-k-1}\}2^{-k-1}\}\)，其中有 \(b-1\) 个 1，\(b\) 为迭代子。其他分隔符遵循 exAN 规则。至此，我们已经完成了记号的展开流程。其余规则与 exAN 相同。

扩张数阵的基本规则如下

\[ s(a,b)=a^b, \]

\[ s(a,b^+,c^+@)=s(a,s(a,b,c^+\#),c\#),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{\circledast_1\mathrm{A}1\mathrm{B}\circledast_2\}=\{\circledast_1\mathrm{B}\circledast_2\},\text{其中}\mathrm{lv(A)}<\mathrm{lv(B)}. \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，则看该项的左侧：

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符形如 \(\{1^{k}\}(k\geq1)\)，则

1. 记该项为 n，则此处的符号形如“\(\{1^{k}\}n\)”；
2. 将“\(\{1\cdot k\}n\)”改写为“\(S_b2\{1^{k}\}n-1\)”，其中字符串函数 \(S_1=\)“，”，\(S_{i+1}=\)“\(\{1S_i2^{k-1}\}\)”；
3. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符不是一个逗号也不是 \(\{1^{\cdot k}\}\)，则：

1. 记该分隔符为 A，记该项为 n，则此处的符号形如“A n”；
2. 把“A n”改写为“A 2 A n-1”；
3. 将目光投向“A 2 A n-1”中第一个“A”中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个“\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如“\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 把“\(\{n@\}\)”改写为 \(S_b\)，其中字符串函数 \(S_1=\)“\(\{n-1@\}\)”，\(S_{i+1}=\)“\(S_i1\{n-1@\}\)”；
3. 流程结束。

带有点号的分隔符等级高于一切不带点号的分隔符，其余比较优先级的规则/流程同扩展数阵。

在新的 B2 情况中，\(\{1\cdot\}\) 展开为 \(\{1\text{ something }2\}^{\prime}\) 的嵌套，而 \(\{1^{k}\}\) 展开为 \(\{1\text{ something }2^{k-1}\}\) 的嵌套。因此我们称之为展开。

\(a[n]\) 的含义同扩展数阵，可以根据流程写出有一定普适性的规则：

1. \(s(a,b,1[n],1,c@)=s(a[n+2],b,c-1@)\)，同线性数阵，但各项之间的分隔符保持不变。
2. 当遇到 \(\{1^{k}\}\)，改写为 \(\{1\{1\{\dots\{1\{1,2^{k}\}2^{k-1}\}\dots\}2^{k-1}\}2^{k-1}\}\)（共 \(b-1\) 层花括号）。
3. 对于既不是逗号又不是 \(\{1^{-k}\}\) 的分隔符 A，\(s(a,b,1[n]Ac-1)=s(a,b,1[n]A2Ac-1)\)，之后对 \(A\) 进行线性数阵的操作，注意这个操作和扩展数阵的要求是一样的。

值得注意的是，在 \(\{2\}\) 之上，对于所有分隔符 A，\(s(n,nA2)\) 的增长率始终为 \(\omega^{\omega^{\alpha}}\)，其中 \(\alpha\) 为某个值。我们称 A 的递归层数为 \(\alpha\)。而 \(s(n,nAk)\) 的增长率为 \(\omega^{\omega^{\alpha}}\times(k-1)\)。

在 \(s(n,n\text{something}A\text{something}A\ldots A\text{something}A\text{something})\) 中，若 A 在数阵第 1 层的所有分隔符中具有最高的递归级别，且 A 的递归级别为 \(\alpha\)，且第 1 层有 k 个 A，则此数阵的增长率为 \(\omega^{\omega^{\alpha}k}\beta+\gamma\)，其中 \(s(n,n\text{something})\)（包含最后一个“something”）的增长率为 \(\beta\)（高于 \(s(n,n,1,2)\)），且 \(s(n,n\text{something}A\text{something}A\ldots A\text{something})\)（不包括最后一个“something”和最后一个 A）的增长率为 \(\gamma\)（高于 \(s(n,n,1,2)\)）。

第二阶段的扩张数阵引入了重音符号，它具有如下的基础规则

\[ s(a,b)=a^b, \]

\[ s(a,b^+,c^+@)=s(a,s(a,b,c^+\#),c\#),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{\circledast_1\mathrm{A}1\mathrm{B}@2\}=\{\circledast_1\mathrm{B}@2\},\text{其中}\mathrm{lv(A)}<\mathrm{lv(B)}. \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，则看该项的左侧：

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符是第一种重音符号，即 \(\{1'\}\)，则

1. 记 \(B_t\) 为包着这个重音符号且层数为 t 的分隔符；
2. 令 \(p=\max\{t\mid A_t\text{而包含这个重音符号且}A_t\text{的右侧花括号不带重音符号}\}\)；
3. 此时字符串 \(B_p\) 形如“P 1 n Q”，改写为 \(S_b\)，其中 \(S_1=\)“，”，\(S_{i+1}=\)“P1\(S_i\)2'n-1Q”；
4. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，记该项为 n，则此处的符号形如“Kn”；
2. 把“K n”改写为“K 2 K n-1”，并令 \(A_t=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向“K 2 K n-1”中第一个“K”中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个“\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如“\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 记 \(S_1=\)“\(\{n-1@\}\)”，\(S_{i+1}=\)“\(S_i1\{n-1@\}\)”；
3. 把“\(\{n@\}\)”改写为 \(S_b\)，其中 b 为迭代子；
4. 流程结束。

带有重音符号的分隔符等级高于一切不带重音符号的分隔符，其余规则/流程同扩展数阵。

下面给出普适性的规则。\(a[n]\) 的含义同扩展数阵，当 \(a=1\) 时且等式前后不强调其个数时，可以简单地用 \(\#\) 表示。

1. \(s(a,b,1[n],1,c@)=s(a[n+2],b,c-1@)\)，同线性数阵，但各项之间的分隔符保持不变。
2. 对于不是逗号的分隔符 A，\(s(a,b,1[n]Ac-1@)=s(a,b,1[n]A2Ac-1@)\)，之后对 A 进行线性数阵的操作，注意这个操作和扩展数阵的要求是一样的。
3. \(\{d@\}=\{d-1@\}1\{d-1@\}1\ldots\{d-1@\}\)（共 \(b\) 个 \(\{d-1@\}\)，注意这个 @ 可以包含第二种重音符号）。
4. \(\{\#1'm@\}=\{\#1\{\#1\{...1\{\#1,2'm-1@\}2...\}2'm-1@\}2'm-1@\}\)（共 \(b\) 层花括号）。
5. 当遇到 \(\{\#1'm@\prime\}\)，就往外找包着它且右花括号不带'的最内层分隔符 \(\{@1,@2\}\)，此时整个分隔符形如 \(\{@,\{\#1'm@\prime\}@2\}\)，注意这个分隔符一定存在，否则为非法表达式，它等于 \(\{@,\{\#1\{\dots\{\#1\{@,\{\#1,2'm-1@\prime\}@2\}2'm-1@^\prime\}\dots\}2'm-1@\prime\}@2\}\)（带有重音符号和不带重音符号的交替展开）。

多重扩张数阵

多重扩张数阵包含连续的重音符号'。连续 \(m\) 个的重音符号，称为 \(m\) 重重音符；对于带有 \(m\) 个重音符号的分隔符 \(\{A\cdots\cdots\}\)，称其具有的重音值为 \(m\)。我们给出其基本规则

\[ s(a,b)=a^b, \]

\[ s(a,b^+,c^+@)=s(a,s(a,b,c^+\#),c\#),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1^{\prime\prime\dots^{\prime}}\}=\{@^{\prime\prime\dots^{\prime}}\}, \]

\[ \{@1A1B@2\}=\{@1B@2\},\text{其中}\mathrm{lv}(A)<\mathrm{lv}(B). \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，则看该项的左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符是 \(m\) 重重音符（记为 \(M\)），则：

1. 记该项为 \(n\)，则此处符号形如“\(M n\)”，将其改写为“\(M 2 M n-1\)”；
2. 记 \(B_x\) 为包着这个重音符号且层数为 \(x\) 的分隔符，当 \(x\) 为 \(M\) 所在的层数时，\(A_x=B_x=M\)。
3. 在所有 \(A_x\) 中，找到重音值小于 \(m\) 且所在层数最大的，并记其下标为 \(t\)；
4. 如果 \(A_t\) 的重音值恰好为 \(m-1\)，则：
   1. 字符串 \(B_t\) 形如“\(P M Q\)”，改写为 \(S_b\)，其中 \(S_1=\)“,”，\(S_{i+1}=\)“\(P S_i Q'\)”；
   2. 流程结束。
5. 如果 \(A_t\) 的重音值小于 \(m-1\)，则：
   1. 易知 \(B_{t+1}\) 一定存在，且此时字符串 \(B_t\) 形如“\(P B_{t+1} Q'\)”；
   2. 将 \(B_t\) 改写为“\(P\{1A_{t+1}2\ldots\}\)”，其中 \(P Q\) 之间的分隔符重音值为 \(m-1\)；
   3. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 \(K\)，记该项为 \(n\)，则此处的符号形如“\(K n\)”；
2. 把“\(K n\)”改写为“\(K 2 K n-1\)”，并令 \(A_t=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向“\(K 2 K n-1\)”中第一个“\(K\)”中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个“\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如“\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 记 \(S_1=\)“\(\{n-1@\}\)”，\(S_{i+1}=\)“\(S_i1\{n-1@\}\)”；
3. 把“\(\{n@\}\)”改写为 \(S_b\)，其中 \(b\) 为迭代子；
4. 流程结束。

对于两个分隔符 \(A\) 和 \(B\)，\(\mathrm{lv}(A)\) 和 \(\mathrm{lv}(B)\) 可比较但没有具体的值，比较的流程如下：

1. 对两者重复应用裁尾规则，直到不能再应用；
2. 若 \(A\) 和 \(B\) 的重音值不相等，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与重音值的序关系相同，流程结束；
3. 令 \(A=\{a_1A_1a_2A_2\dots a_kA_k^{\prime\prime\dots\prime}\},B=\{b_1B_1b_2B_2\dots b_lB_l^{\prime\prime\dots\prime}\}\)；

情况 1：若 \(k=1,l>1\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)，流程结束；

情况 2：若 \(k>1,l=1\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)，流程结束；

情况 3：若 \(k=l=1\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(a_1,b_1\) 的序关系相同，流程结束；

1. 令 \(M(A)=\{i\mid\forall j(\operatorname{lv}(A_i)\geq\operatorname{lv}(A_j))\},M(B)=\{i\mid\forall j(\operatorname{lv}(B_i)\geq\operatorname{lv}(B_j))\}\)；
2. 若 \(\mathrm{lv}(A_{\max M(A)})\neq\mathrm{lv}(B_{\max M(B)})\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(A_{\max M(A)}),\mathrm{lv}(B_{\max M(B)})\) 的序关系相同，流程结束；
3. 若 \(\operatorname{card}(M(A))\neq\operatorname{card}(M(B))\)，则 \(\operatorname{lv}(A),\operatorname{lv}(B)\) 的序关系与 \(\operatorname{card}(M(A)),\operatorname{card}(M(B))\) 的序关系相同，流程结束；
4. 令 \(A=\{\mathbb{Q}_1A_{\max M(A)}\mathbb{Q}_2\},B=\{\mathbb{Q}_3B_{\max M(B)}\mathbb{Q}_4\}\)；
5. 若 \(\mathrm{lv}(\{\circ_2\})\neq\mathrm{lv}(\{\circ_4\})\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(\{\circ_2\}),\mathrm{lv}(\{\circ_4\})\) 的序关系相同，流程结束；
6. \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(\{@1\}),\mathrm{lv}(\{@3\})\) 的序关系相同，流程结束。

Hydra 模式已经出现，带有重音值为 \(m\) 的分隔符的 \(s(n,n\{1^{1}[m]2^{[}m]\}2)\) 增长率和 \(m-1\) 阶 Hydra 的增长率相同。以下把“\(\ldots\)”（共有 \(m\) 个分隔符）简单记作 \([m]\)。

可以把流程写成另一个稍微口语化的流程：

1. 流程开始，记住当前整个式子，姑且称为“原始表达式”，在流程结束之前原始表达式不变，改写式子得到的东西称为“当前表达式”，现在从数阵的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 \(n\)，紧跟在该项之前的东西记作 \(K\)，对 \(K\) 分类讨论：
   1. 2.1 如果 \(K\) 是一个逗号，则将在 \(K\) 之前的、底中的项都改写成底，流程结束；
   2. 2.2 如果 \(K\) 是一个 \(m\) 重重音符号，则将“\(K n\)”改写为“\(K 2 K n-1\)”，以下出现在当前式中的 \(K\) 均是“\(K 2 K n-1\)”中的第一个 \(K\)（这里可以更进一步：如果 \(n=2\)，那么不需要改写）；

在原始式中找到包着 \(K\) 且重音值小于 \(m\) 最内层分隔符 \(A(t)\)，形如 \(@at1K@At2\)；

在当前式中找到与 \(A(t)\) 同一层且包着 \(K\) 的分隔符 \(B(t)\)，形如 \(@Bt1K@Bt2\)；

接着分类讨论：

2.2.1 如果 \(A(t)\) 的重音值等于 \(m-1\)，则将 \(B(t)\) 改写为 \(@Bt1@Bt1\ldots@Bt1,@Bt2\ldots@Bt2@Bt2\)，共有 \(b-1\) 个 \(@Bt2\)，流程结束。

2.2.2 如果 \(A(t)\) 的重音值小于 \(m-1\)，则在 \(B(t)\) 中找到包着 \(K\) 的最外层分隔符 \(B(t+1)\)，\(A(t+1)\) 同理，此时 \(B(t)\) 形如 \(B@t3B(t+1)@Bt4\)，然后把 \(B(t+1)\) 改写为 \(\{1A(t+1)2'[m-1]\}\)，流程结束。

2.3 如果 \(K\) 是别的分隔符，则将“\(K\)”改写为“\(K 2 K n-1\)”，然后看向该分隔符中的第一项（这里可以更进一步：如果 \(n=2\)，那么不需要改写任何地方，因为即使改写为“\(K 2 K 1\)”，“\(K 1\)”立即被裁尾规则裁掉），接下来回到第 2 步。流程结束。

初级下降数阵

初级下降数阵引入了双重逗号作为分隔符。它满足如下的基本规则

\[ s(a,b)=a^{b}, \]

\[ s\left(a,b^{+},c^{+}@\right)=s\left(a,s\left(a,b,c^{+}\#\right),c\#\right),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{@{1}\mathrm{A}1\mathrm{B}@{2}\}=\{@{1}\mathrm{B}@{2}\},\text{其中}\mathrm{lv(A)}<\mathrm{lv(B)}. \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，则看该项的左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符是第一种双重逗号，设其层数为 \(d\)，则：

1. 记 \(B_{x}\) 为而含有这个双重逗号且所在层数为 \(x\) 的分隔符，\(B_{0}\) 为整个数阵；
2. 找到等级小于 \(\mathrm{lv}(,,)\) 的最内层 \(A_{x}\)，并记其下标为 \(t\)；
3. 此时字符串 \(A_{d-1}\) 形如 “X,,n Y”；
4. 若 \(\mathrm{lv}(A_{t})\geq\mathrm{lv}(\text{“X A }A_{d-1}2,,n-1Y\text{”})\)，则：

   a. 此时字符串 \(B_{t}\) 形如 “P \(A_{d-1}\) Q”，改写为 \(S_{b}\)，其中 \(S_{1}=“,”\)，\(S_{i+1}=“PS_{i}Q”\)；

   b. 流程结束。

5. 若 \(\operatorname{lv}(A_t)<\operatorname{lv}(\text{X A}_u2,,n-1Y')\)，则：

   a. 把 \(B_{t+1}\) 改写为 “X \(A_{t+1}\) 2,,n-1 Y”；

   b. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，记该项为 n，则此处的符号形如 “K n”；
2. 把 “K n” 改写为 “K 2 K n-1”，并令 \(A_{t}=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向 “K 2 K n-1” 中第一个 “K” 中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个 “\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如 “\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 记 \(S_{1}=\)“\(\{n-1@\}\)”，\(S_{i+1}=\)“\(S_{i}1\{n-1@\}\)”；
3. 把 “\(\{n@\}\)” 改写为 \(S_{b}\)，其中 b 为迭代子；
4. 流程结束。

双重逗号的等级高于其它任何表达式的等级，其余部分与 exAN 的等级比较规则相同。对于两个分隔符 A 和 B，\(\mathrm{Iv}(A)\) 和 \(\mathrm{lv}(B)\) 可比较但没有具体的值，比较的流程如下：

1. 对两者重复应用裁尾规则，直到不能再应用；
2. 令 \(A=\{a_{1}A_{1}a_{2}A_{2}\dots A_{k-1}a_{k}\},B=\{b_{1}B_{1}b_{2}B_{2}\dots B_{l-1}b_{l}\}\)；

   情况 1：若 \(k=1,l>1\)，则 \(\mathrm{lv}(A)<\mathrm{lv}(B)\)，流程结束；

   情况 2：若 \(k>1,l=1\)，则 \(\mathrm{lv}(A)>\mathrm{lv}(B)\)，流程结束；

   情况 3：若 \(k=l=1\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(a_{1},b_{1}\) 的序关系相同，流程结束；

3. 令 \(M(A)=\{i\mid\forall j(\mathrm{lv}(A_{i})\geq\mathrm{lv}(A_{j}))\},M(B)=\{i\mid\forall j(\mathrm{lv}(B_{i})\geq\mathrm{lv}(B_{j}))\}\)；
4. 若 \(\mathrm{lv}(A_{\max M(A)})\neq\mathrm{lv}(B_{\max M(B)})\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(A_{\max M(A)}),\mathrm{lv}(B_{\max M(B)})\) 的序关系相同，流程结束；
5. 若 \(\operatorname{card}(M(A))\neq\operatorname{card}(M(B))\)，则 \(\operatorname{lv}(A),\operatorname{lv}(B)\) 的序关系与 \(\operatorname{card}(M(A)),\operatorname{card}(M(B))\) 的序关系相同，流程结束；
6. 令 \(A=\{@{1}A_{\max M(A)}@{2}\},B=\{@{3}B_{\max M(B)}@{4}\}\)；
7. 若 \(\mathrm{lv}(\{\circ_{2}\})\neq\mathrm{lv}(\{\circ_{4}\})\)，则 \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(\{\circ_{2}\}),\mathrm{lv}(\{\circ_{4}\})\) 的序关系相同，流程结束；
8. \(\mathrm{lv}(A),\mathrm{lv}(B)\) 的序关系与 \(\mathrm{lv}(\{@{1}\}),\mathrm{lv}(\{@{3}\})\) 的序关系相同，流程结束。

下面是对上述流程的解释。

1. 流程开始，记住当前整个式子，姑且称为 “原始表达式”，在流程结束之前原始表达式不变，改写式子得到的东西称为 “当前表达式”，现在从数阵的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 n，紧跟在该项之前的东西记作 K，对 K 分类讨论：

   2.1 如果 \(K\) 是一个逗号，则将在 \(K\) 之前的、底中的项都改写成底，流程结束。

   2.2 如果 K 是一个双重逗号，则：

   在原始式中找到包着 K 的最内层分隔符 \(A(u)\)，形如 @Au1,,n@Au2；

   在原始式中找到包着 \(A(u)\) 的但等级更低的最内层分隔符 \(A(t)\)，形如 @At1 \(A(u)\) @At2；

   在当前式中找到与 \(A(t)\) 同一层且包着 K 的分隔符 \(B(t)\)，形如 @Bt1 \(A(u)\) @Bt2；

   接着分类讨论：

   2.2.1 如果 \(\operatorname{lv}(A(t))\geq\operatorname{lv}(@Au1A(u)2,,n-1@Au2)\)，则将 \(B(t)\) 改写为

\[ @Bt1\dots@Bt1@Bt1,@Bt2@Bt2\dots@Bt2 \]

1. 共有 \(b-1\) 个 @Bt2，流程结束。

   2.2.2 如果 \(\mathrm{Iv}(A(t))<\mathrm{Iv}(@Au1A(u)2,,n-1@Au2)\)，则在 \(A(t)\) 内找到包着 K 的最外层分隔符 \(A(v)\)，\(B(v)\) 同理，然后把 \(B(v)\) 改写为 @Au1 \(A(v)\) 2,n-1 @Au2，流程结束。

   2.3 如果 K 是别的分隔符，则将 “K” 改写为 “K 2 K n-1”，然后看向该分隔符中的第一项（这里可以更进一步：如果 n=2，那么不需要改写任何地方，因为即使改写为 “K 2 K 1”，“K 1” 立即被裁尾规则裁掉），接下来回到第 3 步。

   2.4 如果 K 是 \(\{\)，则该分隔符形如 \(\{n@\}\)，改写为 \(\{d@\}=\{d-1@\}1\{d-1@\}1...\{d-1@\}\)（共 b 个 \(\{d1@\}\)），流程结束。

接下来可以引入第二种双重逗号。它满足如下的基本规则

\[ s(a,b)=a^{b}, \]

\[ s\left(a,b^{+},c^{+}@\right)=s\left(a,s\left(a,b,c^{+}\#\right),c\#\right),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{@{1}\mathrm{A}1\mathrm{B}@{2}\}=\{@{1}\mathrm{B}@{2}\},\text{其中}\mathrm{lv(A)}<\mathrm{lv(B)}. \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，则看该项的左侧：

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符是第一种双重逗号，即 \(\{1,.,\}\)，则：

1. 记 \(B_{x}\) 为而包含这个双重逗号且所在层数为 x 的分隔符，\(B_{0}\) 为整个数阵；
2. 找到等级小于 \(\mathrm{lv}(\cdot)\) 的最内层 \(A_{x}\)，并记其下标为 \(u\)；
3. 找到等级小于 \(\mathrm{lv}(A_{u})\) 的最内层 \(A_{x}\)，并记其下标为 \(t\)；
4. 此时字符串 \(B_{u}\) 形如 “X,,n Y”；
5. 若 \(\operatorname{lv}(A_t)\geq\operatorname{Iv}("X A_u2,,n-1Y")\)，则：

   a. 此时字符串 \(B_{t}\) 形如 “\(P B_{u} Q\)”，改写为 \(S_{b}\)，其中 \(S_{1}=“,”\)，\(S_{i+1}=“PS_{i}Q”\)；

   b. 流程结束。

6. 若 \(\operatorname{lv}(A_t)<\operatorname{lv}(\text{“}X A_u2,,n-1Y\text{”})\)，则：

   a. 在所有 \(A_{x}\) 中，找到等级最低但大于 \(\mathrm{lv}(A_t)\) 且下标大于 \(t\) 的，并记其下标为 \(v\)；

   b. 此时字符串 \(B_{t}\) 形如 “\(P B_{v} Q\)”，改写为 “\(P X A_{v}2,n-1Y Q'\)”；

   c. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，记该项为 n，则此处的符号形如 “K n”；
2. 把 “K n” 改写为 “K 2 K n-1”，并令 \(A_{t}=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向 “K 2 K n-1” 中第一个 “K” 中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个 “\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如 “\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 记 \(S_{1}=\)“\(\{n-1@\}\)”，\(S_{i+1}=\)“\(S_{i}1\{n-1@\}\)”；
3. 把 “\(\{n@\}\)” 改写为 \(S_{b}\)，其中 b 为迭代子；
4. 流程结束。

分隔符的比较规则与前一部分是相同的。

上述流程可以简要地叙述如下。

1. 流程开始，记住当前整个式子，姑且称为 “原始表达式”，在流程结束之前原始表达式不变，改写式子得到的东西称为 “当前表达式”，现在从数阵的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 n，紧跟在该项之前的东西记作 K，对 K 分类讨论：

   2.1 如果 \(K\) 是一个逗号，则将在 \(K\) 之前的、底中的项都改写成底，流程结束。

   2.2 如果 K 是一个双重逗号，则：

   在原始式中找到包着 K 的最内层不带逗号的分隔符 \(A(u)\)，形如 @Au1,,m@Au2；

   在原始式中找到包着 \(A(u)\) 的但等级更低的最内层分隔符 \(A(t)\)，形如 @At1A(u)@At2；

   在当前式中找到与 \(A(u)\) 同一层且包着这个双重逗号的分隔符 \(B(u)\)，形如 @Bu1,,n@Bu2；

   在当前式中找到与 \(A(t)\) 同一层且包着这个双重逗号的分隔符 \(B(t)\)，形如 @Bt1B(u)@Bt2；接着分类讨论：

   接着分类讨论：

   2.2.1 如果 \(\mathrm{lv}(A(t))\geq1v(@Bu1A(u)2,,n-1@Bu2)\)，则将 \(B(t)\) 改写为

\[ @Bt1...@Bt1@Bt1,@Bt2@Bt2..@Bt2 \]

1. 共有 b 个 @Bt2，流程结束。

   2.2.2 如果 \(\mathrm{lv}(A(t))<\mathrm{lv}(@Bu1A(u)2,,n-1@Bu2)\)，则在 \(A(t)\) 中找到包着这个双重逗号且不带双逗号的最外层分隔符 \(A(v)\)，其形如 @Av1A(u)@Av2；

   在当前式中找到与该分隔符同一层的且包着该双重逗号的分隔符 \(B(v)\)，其形如 @Bv1B(u)@Bv2，此时 Bt 形如 @Bt3@Bv1B(u)@Bv2@Bt4，改写为 @Bt3@Bu1A(v)2,,n-1@Bu2@Bt4，流程结束。

   2.3 如果 K 是别的分隔符，则将 “K n” 改写为 “K 2 K n-1”，然后看向该分隔符中的第一项（这里可以更进一步：如果 n=2，那么不需要改写任何地方，因为即使改写为 “K 2 K 1”，“K 1” 立即被裁尾规则裁掉），接下来回到第 3 步。

   2.4 如果 \(K\) 是 \(\{\)，则该分隔符形如 \(\{n@\}\)，改写为 \(\{d@\}=\{d-1@\}1\{d-1@\}1...\{d-1@\}\)（共 \(b\) 个 \(\{d1@\}\)），流程结束。

次级下降数阵

在这一部分中，我们将重音符号和双重逗号组合在了一起。对于分隔符 \(\{@,,^{\prime\prime}\cdots^{\prime}\}\)（共有 m 个重音符号），称其后重音值为 \(m+1\)，并且这个分隔符可以写作 \(\{@,,^{m+1}\}\)，不带双逗号的分隔符后重音值为 0。其基本规则如下

\[ s(a,b)=a^{b}, \]

\[ s\left(a,b^{+},c^{+}@\right)=s\left(a,s\left(a,b,c^{+}\#\right),c\#\right),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{@{1}\mathrm{A}1\mathrm{B}@{2}\}=\{@{1}\mathrm{B}@{2}\},\text{其中}\mathrm{lv}(\mathrm{A})<\mathrm{lv}(\mathrm{B}). \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，记该项为 n，然后看向左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符为 \(M=\{1,,^{m}\}\)，则：

1. 记 \(B_{x}\) 为而包含这个双重逗号且所在层数为 \(x\) 的分隔符，\(B_{0}\) 为整个数阵；
2. 在所有 \(A_{x}\) 中，找到等级最高但小于 \(\mathrm{lv}(M)\) 的，并记其下标为 u；
3. 如果 \(A_{u}\) 的后重音值小于 \(m-1\)，则：
   1. 把字符串 \(B_{u+1}\) 改写为 “\(\{1A_{u+1}2,,^{m-1}\}\)”；
   2. 流程结束。
4. 在所有 \(A_{x}\) 中，找到等级最高但小于 \(\mathrm{lv}(A_{u})\) 的，并记其下标为 t；
5. 此时字符串 \(B_{u}\) 形如 “X M n Y”；
6. 若 \(\mathrm{lv}(A_{t})\geq\mathrm{Iv}(\text{“X A}_{u}2Mn-1Y\text{”})\)，则：
   1. 此时字符串 \(B_{t}\) 形如 “\(PB_{u}Q\)”，改写为 \(S_{b}\)，其中 \(S_{1}=“,”\)，\(S_{i+1}=“PS_{i}Q”\)；
   2. 流程结束。
7. 若 \(\mathrm{Iv}(A_{t})<\mathrm{lv}(\text{“X}A_{u}2Mn-1Y\text{”})\)，则：
   1. 在所有 \(A_{x}\) 中，找到等级最低但大于 \(\mathrm{lv}(A_t)\) 且下标大于 \(t\) 的，并记其下标为 \(v\)；
   2. 此时字符串 \(B_{t}\) 形如 “\(PB_{v}Q\)”，改写为 “\(PXA_{v}2Mn-1YQ\)”；
   3. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，则此处的符号形如 “K n”；
2. 把 “K n” 改写为 “K 2 K n-1”，并令 \(A_{t}=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向 “K 2 K n-1” 中第一个 “K” 中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个 “\(\{\)”，则：

1. 当前目光所在的分隔符形如 “\(\{n@\}\)”，其中 @ 表示其他内容；
2. 把 “\(\{n@\}\)” 改写为 \(S_{b}\)，其中 \(S_{1}=\text{“”}\{n-1@\}\)，\(S_{i+1}=\text{“}S_{i}1\{n-1@\}\)”；
3. 流程结束。

运算符的比较规则为：

1. 确保参与比较的两个分隔符都不能再应用裁尾规则，并将前重音值改写成后重音值的形式；
2. 后重音值较大的分隔符等级更高；
3. 若两个分隔符后重音值相等，则按照 exAN 的规则比较。

上述流程可以简述如下：

1. 流程开始，记住当前整个式子，姑且称为 “原始式”，在流程结束之前原始表达式不变，改写式子得到的东西称为 “当前式”，现在从数阵的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 n，紧跟在该项之前的东西记作 K，对 K 分类讨论：

2.1 如果 \(K\) 是一个逗号，则将在 \(K\) 之前的、底中的项都改写成底，流程结束。

2.2 如果 \(K\) 是 \(\mathbf{,},^m\)，则：

2.2.1 在原始式中找到包着 \(\mathrm{K}\) 的等级低于 \(\mathrm{K}\) 的最内层分隔符 \(A(u)\)；

并在当前式中找到与 \(A(u)\) 同一层且包着 \(\mathrm{K}\) 的分隔符 \(B(u)\)，形如 @Bu1 K n @Bu2。

2.2.2 在原始式中找到比 \(A(u)\) 高一层且包着 K 的分隔符 \(A(u+1)\)；

并在当前式中找到比 \(B(u)\) 高一层且包着 K 的分隔符 \(B(u+1)\)。

2.2.3 如果 \(A(u+1)\) 的后重音值小于 \(m-1\)，则把 \(B(u+1)\) 改写为 \(1A(u+1)2,m-1\)，流程结束。

2.2.4 在原始式中找到包着 \(A(u)\) 的等级更低的最内层分隔符 \(A(t)\)；

并在当前式中找到与 \(A(t)\) 同一层且包着 \(\mathrm{K}\) 的分隔符 \(B(t)\)，形如 @bt1 \(B(u)\) @Bt2。

接着分类讨论：

2.2.5 如果 \(\mathrm{lv}(A(t))\geq\mathrm{lv}(@Bu1A(u)2Kn-1@Bu2)\)，则：

将 \(Bt\) 改写为 @Bt1\ldots{}@Bt1@Bt1,@Bt2@Bt2\ldots{}@Bt2（共有 \(b-1\) 个 @Bt2），流程结束。

2.2.6 如果 \(\mathrm{lv}(A(t))<\mathrm{lv}(@Bu1A(u)2Kn-1@Bu2)\)，则：

在 \(A(t)\) 中找到包着 K 且等级低于 K 的最外层分隔符 \(A(v)\)；

在当前式中找到与 \(A(v)\) 同层且包着 \(K\) 的分隔符 \(B(v)\)，改写为 @Bu1 \(A(v)\) 2 \(K\) \(n-1\) @Bu2，流程结束。

2.3 如果 K 是别的分隔符，则将 “K n” 改写为 “K 2 K n-1”，然后看向该分隔符中的第一项（这里可以更进一步：如果 n=2，那么不需要改写任何地方，因为即使改写为 “K 2 K 1”，“K 1” 立即被裁尾规则裁掉），接下来回到第 2 步。

2.4 如果 \(K\) 是 \(\{\)，则该分隔符形如 \(\{n@\}\)，改写为 \(\{n-1@\}1\{n-1@\}1\ldots\{n-1@\}\)（共 \(b\) 个 \(\{n-1@\}\)），流程结束。

下面引入三重逗号的表达式。其基本规则与此前是相同的

\[ s(a,b)=a^{b}, \]

\[ s\left(a,b^{+},c^{+}@\right)=s\left(a,s\left(a,b,c^{+}\#\right),c\#\right),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{\text{@}_{1}\mathrm{A}1\mathrm{B}\text{@}_{2}\}=\{\text{@}_{1}\mathrm{B}\text{@}_{2}\},\text{其中}\mathrm{lv}(\mathrm{A})<\mathrm{lv}(\mathrm{B}). \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；

情况 B：如果该项不是 1，记该项为 n，然后看向左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符为三重逗号，设其层数为 d，则：

1. 记 \(B_{x}\) 为而含有这个双重逗号且所在层数为 \(x\) 的分隔符，\(B_{0}\) 为整个数阵；
2. 找到等级小于 \(\mathrm{lv}(A_{d-1})\) 的最内层 \(A_{x}\)，并记其下标为 u；
3. 此时字符串 \(B_{d-1}\) 形如 “X,.,n Y”；
4. 若 \(\mathrm{lv}(A_{u})<\mathrm{lv}(\text{“X}A_{d-1}2,,,n-1Y\text{”})\)，则：
   1. 把 \(B_{u+1}\) 改写为 “\(XA_{u+1}2,,,n-1Y\)”；
   2. 流程结束。
5. 找到等级小于 \(\mathrm{lv}(A_u)\) 的最内层 \(A_x\)，并记其下标为 \(t\)，此时 \(B_u\) 形如 “\(XA_{d-1}2Y\)”；
6. 若 \(\mathrm{lv}(A_{t})<\mathrm{lv}(\text{“}XA_{u}2Y\text{”})\)，则：
   1. 在所有 \(A_{x}\) 中找到等级小于 \(\mathrm{lv}(A_{d-1})\) 但下标大于 t 的，记其下标为 v；
   2. 把 \(B_{v}\) 改写为 “X \(A_{v}\) 2 Y”；
   3. 流程结束。
7. 若 \(\mathrm{lv}(A_{t})\geq\mathrm{lv}(\text{“X A}_{u}2Y\text{”})\)，则：
   1. 此时字符串 \(B_{t}\) 形如 “P \(B_{u}\) Q”，改写为 \(S_{b}\)，其中 \(S_{1}=“,”\)，\(S_{i+1}=“PS_{i}Q”\)；
   2. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，则此处的符号形如 “K n”；
2. 把 “K n” 改写为 “K 2 K n-1”，并令 \(A_{t}=K\)，此处 \(t\) 为 \(K\) 所在的层数；
3. 将目光投向 “K 2 Kn-1” 中第一个 “K” 中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个 “\(\{\)”，则：

1. 当前目光所在的分隔符形如 “\(\{n@\}\)”，其中 @ 表示其他内容；
2. 把 “\(\{n@\}\)” 改写为 \(S_{b}\)，其中 \(S_{1}="\{n-1@\}\)”，\(S_{i+1}="S_{i}1\{n-1@\}\)；
3. 流程结束。

三重逗号的级次高于其他一切分隔符，其余比较规则同 exAN。

上述流程可以解释如下。

1. 流程开始，记住当前整个式子，姑且称为 “原始式”，在流程结束之前原始表达式不变，改写式子得到的东西称为 “当前式”，现在从数阵的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 n，紧跟在该项之前的东西记作 K，对 K 分类讨论：

2.1 如果 K 是一个逗号，则将在 K 之前的、底中的项都改写成底，流程结束。

2.2 如果 K 是三重逗号，则：

2.2.1 在原始式中找到紧包着 K 的最内层分隔符 \(A(d)\)；

在当前式中找到与 \(A(d)\) 同一层且包着 K 的分隔符 \(B(d)\)，形如 @bd1,.,,n @Bd2；

2.2.2 在原始式中找到包着 \(A(d)\) 且等级低于 \(A(d)\) 的分隔符 \(A(u)\)；

在原始式中找到比 \(A(u)\) 高一层且包着 K 的分隔符 \(A(u+1)\)；

在当前式中找到与 \(A(u)\) 同一层且包着 K 的分隔符 \(B(u)\)，形如 @bu1 \(B(d)\) 2 @Bu2；\(B(u+1)\) 同理。

2.2.3 若 \(\mathrm{lv}(A(u))<\mathrm{lv}(@Bd1A(d)2,,n-1@Bd2)\)，则把 \(B(u+1)\) 改写成 “@Bd1 \(A(u+1)\) 2,,n @Bd2”，流程结束。

2.2.4 在原始式中找到包着 \(A(u)\) 且等级低于 \(A(u)\) 的分隔符 \(A(t)\)，\(B(t)\) 同理但形如 @bt1 \(B(u)\) 2 @Bt2。

分类讨论：

2.2.5 如果 \(\mathrm{lv}(A(t))<\mathrm{lv}(@Bu1A(u)2@Bu2)\)，则：

在 \(A(u)\) 中找到等级低于 \(A(d)\) 的分隔符且包着 \(A(d)\) 的分隔符 \(A(v)\)，\(B(v)\) 同理；

把 \(B(v)\) 改写为 @Bu1 A(v) 2 @Bu2，流程结束。

2.2.6 如果 \(\mathrm{lv}(A(t))\geq\mathrm{lv}(@Bu1A(u)2@Bu2)\)，则：

将 \(Bt\) 改写为 @Bt1\ldots{}@Bt1@Bt1,@Bt2@Bt2\ldots{}@Bt2（共有 \(b-1\) 个 @Bt2），流程结束。

2.3 如果 K 是其他分隔符，则将 “K n” 改写为 “K 2 K n-1”，然后看向该分隔符中的第一项（这里可以更进一步：如果 n=2，那么不需要改写任何地方，因为即使改写为 “K 2 K 1”，“K 1” 立即被裁尾规则裁掉），接下来回到第 2 步。

2.4 如果 K 是 \(\{\)，则该分隔符形如 \(\{n@\}\)，改写为 \(\{n-1@\}1\{n-1@\}1...\{n-1@\}\)（共 b 个 \(\{n-1@\}\)），流程结束。

Dropping hydra 模式

回顾一下 exAN 到 sDAN 的流程，出现了很多次“在 xxx 的外面寻找等级更低且包着 xxx 的分隔符”这样的语句，可以据此给分隔符划分阶层：在遇到分隔符 A 时，在展开之前要往外寻找 m 次等级更低的分隔符，我们就把 A 称为“m 阶分隔符”，详情如下。

最基本的分隔符是不带任何标记、只有数阵结构的分隔符，例如 \(\{1,1,2,3\}\)，在操作时不需要关注包着它的是什么形式的分隔符，也就是不需要“往外找”，因此这是 0 阶分隔符。

重音符号'在展开时需要寻找等级低于它的最内层分隔符 \(\{R_1^{\prime}R_2\}\)，然后立即在原重音符号处迭代，而不用考虑 \(\{R_1^{\prime}R_2\}\) 之外的东西，例如

\[ \{1\{1^{\prime}3\}4\}=\{1\{1\{1\dots\{1\}\}\}\} \]

\[ \{1,2^{\prime}2\}2^{\prime}2\}\dots\}2^{\prime}2\}2^{\prime}2\}4\}, \]

只有 \(\{1\_3\}\) 被展开了，外层的 \(\{1\_4\}\) 根本就没动，或者说 \(\{1\_4\}\) 对本次展开没有影响。由于在展开之前只需要往外寻找 1 次“等级较低的分隔符”，所以重音符号是一种“1 阶分隔符”（由于此时数阵的等级由右花括号的左上角重音符号的个数决定，所以往外寻找时不用完整地执行一遍等级比较规则），注意：\(\{R_1^{\prime}R_2\}\) 是一个 0 阶分隔符。

接下来看双重逗号，由于单个重音符号可以等价地改写为 \(\{1,2\}\)，于是 \(\{1'3\}\) 就变成了 \(\{1\{1,,2\}3\}\)，这时我们可以发现，若要拆开双重逗号，涉及到不仅仅是 1 层“等级较低的分隔符”，而是 2 层了：内层的 \(\{1\_2\}\) 还不能完全决定展开结果，外层的 \(\{1\_3\}\) 也有影响。由于在展开之前需要往外寻找 2 次“等级较低的分隔符”，所以我们把双重逗号称为“2 阶分隔符”。注意第一次找到的“等级较低的分隔符” \(\{R_1,,R_2\}\) 是一个 1 阶分隔符，第二次找到的 \(\{R_3\{R_1,,R_2\}R_4\}\) 是一个 0 阶分隔符，如果找不到“等级较低的分隔符”，就要手动套上，此为分隔符的“降阶”。此外还要注意，在找到第二个“等级较低的分隔符”之后，还要验证 \(\{R_3\_R_4\}\) 是否达到了某个等级，如果没达到，就应该在 \(\{R_3\_R_4\}\) 内手动添加某个满足要求的分隔符。以上操作全部完成后，便重复书写 0 阶和 1 阶分隔符之间的内容（包括 0 阶分隔符本身，但不包括 1 阶分隔符），即为“展开”。

SAN 对应的表达式是 \(\{1\{1,,1\{1,,4\}2,,2\}2,,2\}\)，遇到的是第二个双重逗号，此时应该往外寻找等级低于双重逗号的分隔符：\(\{1,,4\}\)，再往外找一次：\(\{1\{1,,1\{1,,4\}2,,2\}2,,2\}\)，由于这个分隔符等级低于 \(\{1\_2,,3\}\)，所以应该在 \(\{1\_2,,2\}\) 内手动添上 \(\{1\_2,,3\}\)，最后成为

\[ \{1\{1\{1,,1\{1,,4\}2,,2\}2,,3\}2,,2\}, \]

展开成

\[ \begin{array}{l} \{1\{1\{1,,1\{1\{1,,\{\dots\}\}\}\}\\ \{1\{1,,1\{1\{1,,1,2,,2\}2,,3\}2,,2\}2,,3\}...\}\\ 2,,2\}2,,3\}2,,2\}2,,3\}2,,2\}. \end{array} \]

接下来看三重逗号，由于双重逗号可以等价地改写为 \(\{1,.,2\}\)，所以 \(\{1'3\}\) 就变成了

\[ \{1\{1\{1,,,2\}2\}3\}, \]

影响展开结果的“等级较低的分隔符”又多了一层，这便是“3 阶分隔符”。首先寻找等级低于三重逗号的最内层分隔符（第一次），得到 2 阶分隔符；接着再寻找第二次，然后等级比较，不满足则手动添加，最终得到 1 阶分隔符；接着再寻找第三次，然后等级比较，不满足则手动添加，得到 0 阶分隔符；最后重复书写 0 阶和 1 阶分隔符之间的内容（即展开）。

例如只有单独的 \(\{1,.,4\}\)，这是一个 2 阶分隔符，由于外面没有符号，因此需要手动添加，得到 \(\{1\{1,.,4\}2,.,3\}\)，这是一个 1 阶分隔符，再次手动添加，得到

\[ \{1\{1\{1,.,,4\}2,,,3\}2,,,3\}, \]

只是一个 0 阶分隔符，现在可以展开

\[ \{1\{1\{1\dots\{1\{1,2,,,3\}2,,,3\}\dots\}2,,,3\}2,,,3\}. \]

下面考虑一个更加复杂的例子：

\[ \{1,,,1\{1\{1,,,1,,,3\}2,,,1,,,3\}2\}. \]

遇到的是第三个三重逗号，是一个 3 阶分隔符，立即寻找等级较低的分隔符（第一次），得到 \(\{1,.,1,.,3\}\) 这是一个 2 阶分隔符；接着寻找第二次，得到

\[ \{1,,,1\{1\{1,,,1,,,3\}2,,,1,,,3\}2\}, \]

由于 \(\{1,.,,1\_2\}\) 的等级小于 \(\{1,.,,1\_2,.,,2\}\) 的等级，所以需要手动添加，得到

\[ \{1,.,,1\{1,.,,1\{1\{1,.,,1,.,,3\}2,.,,1,.,,3\}2,.,,2\}2\}, \]

这是一个 1 阶分隔符；接着寻找第三次，外面没有了，所以把 1 阶分隔符和 2 阶分隔符之间的内容

\[ \{1,.,,1\{1,.,,1\{1\{1,.,,1,.,,3\}2,.,,1,.,,3\}2,.,,2\}2\}, \]

手动添加到外面，得到

\[ \begin{array}{l} \{1,.,,1\{1,.,,1\{1\{1,.,,1\{1,.,,1\{1\}\}\}\}\}\\ 1,.,,1,,,3\}2,.,,1,,,3\}2,.,,2\}2\}2,.,,1,,,3\}2,.,,2\}2\} \end{array} \]

最后重复书写 0 阶和 1 阶分隔符之间的内容，得到

\[ \begin{array}{l} \{1,.,,1\{1,.,,1\{1\{1,.,,1\{1,.,,1\{1\{\dots\}\}\}\}\\ \{1,.,,1\{1,,,1\{1\{1,,,1\{1,,,1\{1,2,,,1,,,\\ 3\}2,,,2\}2\}2,,,1,,,3\}2,,,2\}2\}...\}\\ 2,.,,1,,,3\}2,.,,2\}2\}2,.,,1,,,3\}2,.,,2\}2\},,2\}2\}. \end{array} \]

在上面这个例子中，寻找第三次时手动添加的是 1 阶分隔符和 2 阶分隔符之间的内容，寻找第二次时手动添加的却不是 2 阶分隔符和 3 阶分隔符之间的内容，而是流程中规定的另外的内容，这很让人恼火，我们希望能把这个规律应用到第二次寻找中。然而可以发现，如果第一次寻找到的分隔符是 \(\{R_1,,,n\ R_2\}\)，那么第二次寻找时手动添加的内容就是 \(\{R_1\_\_\_2,,,n-1\ R_2\}\)。因此，可以在遇到三重逗号“,,,n”时就立即改写为“,,,2,,,n-1”，并把前一个三重逗号定为接下来提到的“3 阶分隔符”，那么第二次手动添加的内容便是 2 阶分隔符和 3 阶分隔符之间的内容了。

顺着以上 2 阶、3 阶分隔符的思路，我们便可以推广到任意阶分隔符。若遇到 m 重逗号（记为 K），立即把“K n”改写为“K 2 K n-1”，并把第一个 K 记为 M，然后寻找等级小于 M 的分隔符（第一次），得到 \(\{R_1 K R_2\}\)。这是 \(m-1\) 阶分隔符，接着：

第二次寻找等级更低的分隔符，得到 \(\{R_3\_R_4\}\)，若等级小于 \(\{R_1\_R_2\}\)，则将后者放入前者中，得到 \(m-2\) 阶分隔符；

第三次寻找更低的分隔符，得到 \(\{R_5\_R_6\}\)，若等级小于 \(\{R_3\_R_4\}\)，则将后者放入前者中，得到 \(m-3\) 阶分隔符；

第四次寻找更低的分隔符，得到 \(\{R_7\_R_8\}\)，若等级小于 \(\{R_5\_R_6\}\)，则将后者放入前者中，得到 \(m-4\) 阶分隔符；

第 \(k\) 次寻找更低的分隔符，得到 \(\{R_{2k-1}\_R_{2k}\}\)，若等级小于 \(\{R_{2k-3}\_R_{2k-2}\}\)，则将后者放入前者中，得到 \(m-k\) 阶分隔符；

第 \(m\) 次寻找更低的分隔符，得到 \(\{R_{2m-1}\_R_{2m}\}\)，若等级小于 \(\{R_{2m-3}\_R_{2m-2}\}\)，则将后者放入前者中，得到 0 阶分隔符；

最后重复书写 0 阶和 1 阶分隔符之间的内容，展开完成。

以上便是 Dropping Hydra 模式，依照这种模式很容易定义出达到 DAN 强度的表示法。

下降数阵

这是 SAN 良定义的最强部分，引入了任意多重逗号，而且只作为分隔符，不出现在分隔符右花括号的左上方，不同的逗号可以相互转化：,,\ldots,,（m 重）\(=\{1,.,.,.,2\}\)（\(m+1\) 重）。DAN 译作“下降数阵”，是因为遇到多重逗号之后，不能马上像 EAN 那样展开，而是需要往外不断确定越来越低阶的分隔符（不满足条件就手动添加一些内容），直到确定 0 阶分隔符。当 k 阶分隔符确定以后，其内部的东西就不再变化。在最终以 EAN 的方式展开之前，得到确定的分隔符越来越低阶，这就是“降阶”的概念。由于 DAN 表达式操作完后流程不一定结束，所以在每一次操作之前可能需要暂时记住操作之前的式子，为后续的操作提供参考（这也是 DAN 的流程难以改写成规则的重要原因）。因此，在接下来的流程中，出现了“原始式”和“当前式”这两个表达式，两者相互参考。

首先给出合法表达式界定标准（此处 A 和 B 为类型不定，因此更为严格的界定需要用到类型论）：

1. 任意重逗号（,,\ldots,,）是分隔符；
2. 对于正整数 \(m,\{m\}\) 是分隔符；
3. 若 \(\{A\}\)、B 都是分隔符，m 是正整数，则 \(\{ABm\}\) 是分隔符；
4. 对于正整数 a 和 b，\(s(a,b)\) 是合法表达式（数阵）；
5. 若 \(\{A\}\)、B 都是分隔符，m 是正整数，则 \(s(ABm)\) 是合法表达式（数阵）；
6. 不能由前 5 条规则构造出来的表达式视作非法表达式。

下降数阵的基本规则为

\[ s(a,b)=a^{b}, \]

\[ s\left(a,b^{+},c^{+}@\right)=s\left(a,s\left(a,b,c^{+}\#\right),c\#\right),b,c\neq1, \]

\[ s(@A1)=s(@), \]

\[ \{@A1\}=\{@\}, \]

\[ \{@{1}A1B@{2}\}=\{@{1}B@{2}\},\text{其中}\mathrm{lv}(A)<\mathrm{lv}(B). \]

若规则都不适用，则进入下面的流程，首先请看数阵的第 3 项。流程开始。

情况 A：如果该项是 1，则看数阵的下一项，回到流程开始处；情况 B：如果该项不是 1，则看该项的左侧；

情况 B1：如果紧跟在该项之前的分隔符是一个逗号，则：

1. 把该项减 1，紧跟在逗号之前的那一项改写为迭代子；
2. 把这两项之前的、在底中的所有项都改写为底；
3. 流程结束。

情况 B2：如果紧跟在该项之前的分隔符为 m 重逗号，记为 M，则：

1. 此处符号形如“M n”，将其改写为“M 2 M n-1”，并将前一个 M 记为 \(B_{u(m+1)}\)；
2. 记 \(B_{x}\) 为而包含 \(B_{u(m+1)}\) 且所在层数为 \(x\) 的分隔符；
3. 在所有 \(A_{x}\) 中，找到等级最高但小于 \(\mathrm{lv}(M)\) 的，并记其下标为 \(u(m)\)；
4. 如果 \(\mathrm{lv}(A_{u(m)})<\mathrm{lv}(,)\)，则：
   1. 此时字符串 \(B_{u(m)}\) 形如“\(PB_{u(m)+1}Q\)”，改写为“\(P\{1A_{u(m)+1}2\}Q\)”；
   2. 流程结束。
5. 令 \(j=m\)，\(A_{u(m+1)}=B_{u(m+1)}\)。

小流程开始。

1. a.将 j 减去 1，找到最大的 \(u(j)\) 使得 \(\mathrm{lv}(A_{u(j)})<\mathrm{lv}(A_{u(j+1)})\)；

   b.此时的 \(B_{u(j+1)}\) 形如“X \(B_{u(j+2)}\) 2 Y”，如果 \(\mathrm{lv}(A_{u(j)})<\mathrm{lv}(\text{“}XA_{u(j+1)}2Y\text{”})\)，则：

   c.找到最小的 \(v(j)\)，使得 \(v(j)>u(j)\) 且 \(\mathrm{lv}(A_{v(j)})<\mathrm{lv}(A_{u(j+2)})\)；

   1. i.此时 \(B_{u(j)}\) 形如“\(PB_{v(j)}Q\)”，改写为“\(PXA_{v(j)}2YQ\)”；
   2. ii.流程结束。
   3. iii.如果 \(j>1\)，回到小流程开始处。
2. 此时字符串 \(B_{u(1)}\) 形如“P \(B_{u(2)}\) Q”，改写为 \(S_{b}\)，其中 \(S_{1}=“,”\)，\(S_{i+1}=“PS_{i}Q”\)；
3. 流程结束。

情况 B3：如果紧跟在该项之前的分隔符为其他形式，则：

1. 记该分隔符为 K，记该项为 n，则此处的符号形如“Kn”；
2. 把“Kn”改写为“K2Kn-1”，并令 \(A_{t}=K\)，此处 t 为 K 所在的层数；
3. 将目光投向“K2Kn-1”中第一个“K”中的第一项，回到流程开始处。

情况 B4：如果紧跟在该项之前的东西不是一个分隔符，而是一个“\(\{\)”，则：

1. 记该项为 \(n\)，则当前目光所在的分隔符形如“\(\{n@\}\)”，其中 @ 表示分隔符内其他内容；
2. 记 \(S_{1}=\text{“}\{n-1@\}\)”，\(S_{i+1}="S_{i}1\{n-1@\}\)”；
3. 把“\(\{n@\}\)”改写为 \(S_{b}\)，其中 b 为迭代子；

4.流程结束。

运算符级次的比较规则如下：

1. 如果紧包在 \(m\) 重逗号周围的不是 \(\{1\_2\}\)，则将该 \(m\) 重逗号改写成 \((m+1)\) 重逗号 \(\{1,\dots,2\}\) 的形式；
2. 逗号的重数越大，分隔符的等级越高；
3. 完整的数阵是一个数字，但也可以参与比较，其等级小于任何分隔符；
4. 其余的规则同 exAN。

下面我们考察 DAN 是如何使用 Dropping Hydra 模式的。首先是“高阶分隔符”的概念。以遇到的 m 重逗号作为基准，把该 m 重逗号确定为 m 阶分隔符。一旦确定了 k 阶分隔符（记为 A），就往外找包着 A 且等级低于 A 的最内层分隔符 B，B 即可确定为 \((k-1)\) 阶分隔符。接着可以根据高阶分隔符定义“高级分隔符”的概念：

以 \(m\) 阶逗号为基准，若存在 \((k+1)\) 阶和 \((k+2)\) 阶分隔符，在确定第 \(k\) 阶分隔符时，满足以下 3 个条件的最外层分隔符称为某分隔符的“高级分隔符”：

（1）被该分隔符中包着；

（2）包着 \((k+1)\) 阶分隔符，或者是 \((k+1)\) 阶分隔符本身；

（3）等级低于 \((k+2)\) 阶分隔符。

例如，对于以下的数阵来说

\[ \{1\{1\{1,,3\}1\{1\{1\{1,,,3\}2,,,3\}2,,,2\}2,,,2\}2,,,4\} \]

对于第一个三重逗号，以它为基准，它是 3 阶分隔符，包着它且等级低于它的最内层分隔符是 \(\{1,.,,3\}\)。这是 2 阶分隔符，它的高级分隔符是三重逗号，恰好是 3 阶分隔符本身。

对于 \(\{1,.,3\}\)，包着它且等级低于它的最内层分隔符是

\[ \{1\{1\{1,,,3\}2,,,3\}2,,,2\}. \]

这是 1 阶分隔符，它的高级分隔符是 \(\{1\{1,,,3\}2,,,3\}\)。

对于 \(\{1\{1\{1,.,,3\}2,.,,3\}2,.,,2\}\)，包着它且等级低于它的最内层分隔符是

\[ \{1\{1,,3\}1\{1\{1\{1,,,3\}2,,,3\}2,,,2\}2,,,2\}. \]

这是 0 阶分隔符，它的高级分隔符是

\[ \{1\{1\{1,.,,3\}2,,,3\}2,,,2\}, \]

恰好是 2 阶分隔符。

DAN“降阶”操作的流程如下（此时假设第 k 阶和第 \((k+1)\) 阶分隔符已经确定，但 k-1 阶分隔符尚未确定，现在的目标就是确定它）：

1. 把原始式中第 \(k\) 阶分隔符记作 \(A(k)\)，当前式中第 \((k+1)\) 阶分隔符记为 \(B(k+1)\)，则第 \(k\) 阶分隔符形如 \(\{R_1,B(k+1),R_2\}\)；
2. 往外寻找包着 \(A(k)\) 且等级低于 \(A(k)\) 的分隔符 \(A(k-1)\)（若不存在则为整个数阵）。
3. 若 \(\operatorname{lv}(A(k-1))<\operatorname{lv}(\{R_1A(k)R_2\})\)，则：
   1. 3.1 记 \(A(k-1)\) 的高级分隔符为 \(C(k-1)\)；
   2. 3.2 把当前式中与 \(C(k-1)\) 层数相等且包着 m 重逗号的分隔符记为 \(D(k-1)\)；
   3. 3.3 把 \(D(k-1)\) 改写成 \(\{R_1C(k-1)R_2\}\)，并重新设定 \(A(k-1)\) 为 \(\{R_1C(k-1)R_2\}\)；
   4. 3.4 把原始式改写为当前式。
4. 把 \(A(k-1)\) 确定为第 \((k-1)\) 阶分隔符。

了解了高阶分隔符、高级分隔符和降阶的概念之后，解释 DAN 的流程就容易多了。

1. 流程开始，令原始式和当前式为整个数阵，然后从当前式的第 3 项看起。
2. 如果该项为 1，则看向下一项，如果仍为 1，就看向再下一项，直到找到不为 1 的项，此时记该项为 n，紧跟在该项之前的东西记作 K，对 K 分类讨论：

2.1 如果 \(K\) 是一个逗号，则将在 \(K\) 之前的、底中的项都改写成底，流程结束。

2.2 如果 \(K\) 是 \(m\) 重逗号，则：

2.2.1 将原始式中对应的 K 记作 \(A(m)\)，即 m 阶分隔符，当前式中此处形如“K n”，改写为“K 2 K n-1”，并将前一个 K 记作 \(B(m)\)；

2.2.2 往外找包着 \(A(m)\) 且等级低于 \(A(m)\) 的最内层分隔符：若找得到，则将其记为 \(A(m-1)\)，即 \(m-1\) 阶分隔符；若找不到，则在包着 \(A(m)\) 最外层分隔符外面套上 \(\{1\_2\}\)，并把整体记为 \(A(m-1)\)，即 \(m-1\) 阶分隔符，然后把当前式改写成原始式；

2.2.3 继续实施降阶操作，确定各阶分隔符。

2.2.4 把 \(B(0)\) 除去 \(B(1)\) 后的内容记为 \(\{R\_R'\}\)，然后把 \(B(0)\) 改写为

\[ \{R\{R\{\dots\{R\{R,R^{\prime}\}R^{\prime}\}\dots\}R^{\prime}\}R^{\prime}\}, \]

一共嵌套 \(b-1\) 层，流程结束。

2.3 如果 K 是其他分隔符，则将“K n”改写为“K 2K n-1”（注意此时也许可以使用裁尾规则），然后看向该分隔符中的第一项，接下来回到第 2 步。

2.4 如果 \(K\) 是 \(\{\)，则该分隔符形如 \(\{n@\}\)，改写为 \(\{n-1@\}1\{n-1@\}1\ldots\{n-1@\}\)（共 b 个 \(\{n-1@\}\)），流程结束。