查看“︁反射序数”︁的源代码

反射是一个非递归记号。它表示非递归序数，其特点是并不会表示其极限之下的所有序数。它具有深厚的集合论背景

== 数学定义 ==
''前排提醒：对数学定义不感冒或者看不懂的读者可以跳到后面''

根据命题中无界量词的性质，给出公式的层次：

满足如下条件之一的集合论公式称为 <math>\Delta_0</math> 公式：

# 它不包含无界量词
# 它形如 <math>\varphi\land\psi,\varphi\lor\psi,\neg\varphi,\varphi\rightarrow\psi,\varphi\leftrightarrow\psi</math>，其中 <math>\varphi,\psi</math> 为 <math>\Delta_0</math> 公式
# 它形如 <math>(\exists x\in y)\varphi</math> 或 <math>(\forall x\in y)\varphi</math>，其中 <math>\varphi</math> 为 <math>\Delta_0</math> 公式

<math>\Delta_0</math> 公式中的所有量词都是有界的。

<math>\Sigma_n</math> 公式及 <math>\Pi_n</math> 公式定义如下：

# <math>\Sigma_0</math> 公式及 <math>\Pi_0</math> 公式为 <math>\Delta_0</math> 公式。
# 如果 <math>\varphi</math> 为 <math>\Pi_n</math> 公式，则 <math>\exists x_1\cdots\exists x_m\varphi</math> 为 <math>\Sigma_{n+1}</math> 公式。
# 如果 <math>\varphi</math> 为 <math>\Sigma_n</math> 公式，则 <math>\forall x_1\cdots\forall x_m\varphi</math> 为 <math>\Pi_{n+1}</math> 公式。

反射的定义：

L 为[[可构造宇宙]]，<math>L_\alpha</math> 在 X 上反射了公式 <math>\varphi</math>，是说 <math>L_\alpha\models\varphi\Rightarrow\exists\beta\in(X\cap\alpha)L_\beta\models\varphi</math>。若 <math>L_\alpha</math> 在 X 上反射了所有的 <math>\Pi_n(\Sigma_n)</math> 公式，则称 α 是 X 上的 <math>\Pi_n(\Sigma_n)</math> 序数。特别的，若 <math>L_\alpha</math> 在所有序数上反射了所有的 <math>\Pi_n(\Sigma_n)</math> 公式，则称 α 是 <math>\Pi_n(\Sigma_n)</math> 序数。

或者说，一个序数 <math>\beta</math> 被称为 <math>X</math> 上的 <math>\Gamma-\text{反射序数}</math>，当且仅当 <math>\forall\psi\in\Gamma(L_\beta\models\psi\Rightarrow\exists\gamma\in(X\cap\beta)(L_\gamma\models\psi))</math>。

关于反射序数有如下的重要结论：

* α 是 X 上的 <math>\Pi_n</math> 反射序数，等价于 α 是 X 上的 <math>\Sigma_{n+1}</math> 反射序数（也就是说，我们只需要研究集合上的 <math>\Pi_n</math> 反射序数即可）
* α 是 X 上的 <math>\Pi_0</math> 反射序数，等价于 α 是 X 上的 <math>\Pi_1</math> 反射序数，等价于 α 是 X 上的极限点
* α 是 X 上的 <math>\Pi_2</math> 反射序数，等价于 α 是 X 上的容许序数

注：在一些资料中，会出现 <math>\Pi_0</math> 反射等价于全体序数的说法。这是错误的。事实上，如果我们想要写出全体序数，应该写出 <math>\bold{Ord}</math>（或 <math>\bold{On}</math>）

== 结构讲解 ==

=== 基本符号 ===

==== onto ====
onto 是反射模式的核心。它的作用对象是一个集合，同时也输出一个集合。例如： <math>\Pi_1\ \mathrm{onto}\ \bold{Ord}</math>，得到的是全体极限序数构成的集合；<math>\Pi_2\ \mathrm{onto}\ \bold{Ord}</math>构成的集合，得到的是全体容许序数构成的集合。

方便起见，我们把 <math>\Pi_n\ \mathrm{onto}\ X</math> 简写为 n-X 。这里的 n 是自然数， X 是被操作的集合。特殊地，当 X 为全体序数，我们直接将它省略不写，此时的结果直接记为 n 。也就是说，在反射模式中， 1 可以用来表示 <math>\Pi_1\ \mathrm{onto}\ \bold{Ord}</math> 的结果，以此类推。

即：<math>\Gamma-\text{ref. onto }X</math> 定义为所有 X 上的 Γ-反射序数的集合。

==== ∩ ====
这里的 ∩ 指交集。没错，就是那个大家熟知的交集， <math>A\cap B</math> 表示同时属于集合 A 和集合 B 的元素。交集也是反射模式中的一种重要运算。同样是为了方便起见，我们将 ∩ 简写为空格。 ∩ 在反射式中的运算优先级与 onto 相同，并且从右向左计算。例如： 2 1-2 表示<math>\Pi_2\cap(\Pi_1\ \mathrm{onto}\ \Pi_2)</math> 的集合； 2-3 1-3 2-3 表示 <math>\Pi_2\ \mathrm{onto}\ (\Pi_3\cap(\Pi_1\ \mathrm{onto}\ (\Pi_3\cap(\Pi_2\ \mathrm{onto}\ \Pi_3))))</math> 的集合。

==== <math>\mathrm{min,2nd,3rd}</math> 以及 <math>n\mathrm{th}</math> ====
反射模式研究的集合中的元素都是序数。因此，我们可以把这些序数从小到大进行排序，并用 <math>\mathrm{2nd}\ X,\mathrm{ 3rd}\ X,n\mathrm{th}\ X</math> 来分别表示集合 X 中从小到大的第 2 、第 3 以及第 n 个元素。不过，对于 X 中的第 1 个元素，我们一般不叫它 <math>\mathrm{1st}\ X</math>，而是叫它 min X 。在不引起歧义的情况下，也可以把这个 min 省略，直接用 X 来指代 X 中的第一个元素。在会引起歧义的场合，则用 (X) 来代表 min X 。不建议使用 <math>\omega\mathrm{th}</math> 之类的“第超限序数个”的表达。

==== aft ====
将序数从小到大排序，排在后面的就是更大的序数。因此， <math>A\ \mathrm{aft}\ B</math> 表示“集合 A 中大于序数 B 的元素”。将这一表达与 <math>\min,\ \mathrm{2nd},\ \mathrm{3rd}</math> 等结合起来，可以得到 <math>\min\ A\mathrm{\ aft}\ B</math>、 <math>2\mathrm{nd}\ A\mathrm{\ aft}\ B</math> 等，分别表示“集合 A 中最小的大于序数 B 的元素”和“集合 A 中第二个大于序数 B 的元素”。

=== <math>\Pi_1</math> 反射 ===

==== 1- 的作用 ====
<math>\Pi_1\ \mathrm{onto}</math> 一个集合的效果，是取出这个集合中所有的极限点。所谓的极限点，就是前极限序数个元素的上确界。

现在我们可以来推导一下 1 ，也即 <math>\Pi_1\ \mathrm{onto}</math> 全体序数的构成。

具体地，我们需要遍历全体极限序数 α ，并找到前 α 个序数的上确界。

前 ω 个序数的上确界为 ω，前 <math>\omega\times2</math> 个序数的上确界为 <math>\omega\times2</math>……

事实上， 1 就等于全体极限序数的集合 <math>\{\omega,\omega\times2,\dots,\omega^2,\dots,\omega^\omega,\dots\Omega,\dots\}</math>。

类似地， 1 中的前 ω 个序数的上确界是 <math>\sup\{\omega,\omega\times2,\omega\times3,\dots\}=\omega^2</math>，1 中的前 <math>\omega\times2</math> 个序数的上确界是 <math>\sup\{\omega,\omega\times2,\dots,\omega^2,\omega^2+\omega,\dots\}=\omega^2\times2</math>……因此，<math>1-1=\{\omega^2,\omega^2\times2,\dots,\omega^3,\dots,\omega^\omega,\dots,\Omega,\dots\}</math>，是 <math>\omega^2</math> 的倍数的集合。

继续递推，还能得到

<math>1-1-1= \{\omega^3,\omega^3\times2,\dots,\omega^\omega,\dots,\Omega,\dots\}</math>

<math>1-1-1-1=\{\omega^4,\omega^4\times2,\dots,\omega^\omega,\dots,\Omega,\dots\}</math>

……直到：

==== <math>(1-)^\omega</math> ====
方便起见，我们把重复的 1- 合并合并。把重复的操作用括号括起来，上标表示重复次数。这样， 1-1-1 可以写作<math>(1-)^3</math> ， 1-1-1-1 可以写作<math>(1-)^4</math> 。对于这种有限次的 1- ，我们都可以递归地得到它代表的集合。

但，<math>(1-)^\omega</math>呢？

我们首先需要定义 <math>(1-)^\omega</math>。较一般地，对于 <math>(1-)^\alpha</math> ，其中 α 为极限序数的情况，我们只需要取交集，即定义 <math>(1-)^\alpha=\bigcap_{\beta<\alpha}(1-)^\beta</math>。

自然地，我们可以推导出 <math>(1-)^\omega=\{\omega^\omega,\omega^\omega\times2,\dots,\omega^{\omega+1},\dots,\Omega,\dots\}</math>，即 <math>\omega^\omega</math> 的倍数的集合。

<math>(1-)^\alpha</math>，就是 <math>\omega^\alpha</math> 的倍数的集合，<math>\min\ (1-)^\alpha=\omega^\alpha</math>。

==== <math>(1-)^{1,0}</math> 等 ====
上标只能放序数的情形是简单的，一个“<math>\omega^\alpha</math> 的倍数”就直接解决了。如何让情形变得更有趣呢？我们可以借用 [[Veblen 函数]]的不动点进位模式，在上标上引入多个数字，来表示不同层级的不动点。

我们定义 <math>(1-)^{1,0}=\{\alpha|\alpha=\min\ (1-)^\alpha\}</math>。根据上一节的结论，我们可以知道 <math>\min\ (1-)^\alpha=\omega^\alpha</math>。因此，<math>(1-)^{1,0}</math>是全体 <math>\varepsilon</math> 序数的集合，即 <math>\{\varepsilon_0,\varepsilon_1,\dots,\varepsilon_\omega,\dots,\zeta_0,\dots,\Omega,\dots\}</math>。

可以继续对 <math>(1-)^{1,0}</math> 进行 1- 的操作，得到的集合记为 <math>(1-)^{1,1}</math>。<math>(1-)^{1,1}</math> 应当是全体“下标为极限序数的 <math>\varepsilon</math> 序数”的集合，即<math>(1-)^{1,1}=\{\varepsilon_\omega,\varepsilon_{\omega\times2},\dots,\varepsilon_{\omega^2},\dots,\zeta_0,\dots,\Omega,\dots\}</math>。

更一般地，我们在上标上使用 [[weak Veblen 函数]]，记 <math>1-(1-)^{\#,\alpha}</math> 为 <math>(1-)^{\#,\alpha+1}</math>。于是，我们还可以有 <math>(1-)^{1,2},(1-)^{1,\omega},(1-)^{1,\varepsilon_0},\dots</math>。在上标遇到极限序数时，我们也仍取交集。

直到我们遇见了新的不动点。我们定义 <math>(1-)^{2,0}=\{\alpha|\alpha=\min\ (1-)^{1,\alpha}\}</math>。借用 Veblen 函数的模式，我们还能把定义推广到 <math>(1-)^{1,0,0}</math> 等等并且还能在此基础上进行扩展。理论上，只要扩展足够强力，所有的递归序数都能像这样被表示出来。

值得一提的是，本条目折叠不动点采用了 Veblen 函数式的写法。事实上，是存在 [[序数坍缩函数|OCF]] 式的写法的。读者可以参见条目 [[Σ1稳定序数|Σ1 稳定序数]]。

=== <math>\Pi_2</math> 反射和容许序数 ===
<math>\Pi_2~\mathrm{onto}</math> 任意集合的作用，暂时是难以说明的，所以我们先从 <math>\Pi_2\ \mathrm{onto}\ \bold{Ord}</math> 开始。这里不加证明地给出以下结论：<math>\Pi_2</math> 反射作用于全体序数的集合，得到的是全体容许序数的集合。

所谓容许序数，可以大致地理解为无法通过比它小的序数进行递归运算得到的序数。所谓的“无法通过比它小的序数进行递归运算得到的序数”，换用另一个更直观的概念，就是“不存在长度小于它的、递归表达的基本列的序数”。也就是说，如果我们找到了某个序数的一条长度小于它本身的基本列，就能立刻断言它不是容许序数。这为我们排除很多容许序数的备选提供了一条可行的方案。

最小的容许序数是 [[CKO|Church-Kleene 序数]]，记为 <math>\omega_1^{CK}</math>，在这里我们把它写作 <math>\Omega</math>——没错，就是在 [[序数坍缩函数|OCF]] 中出现的那个。

紧接着，第二个容许序数是 <math>\omega_2^{CK}</math>，在这里写作 <math>\Omega_2</math>。它无法通过包括 <math>\Omega</math> 在内的比它小的序数通过递归运算得到，这意味着 <math>\Omega_2</math> 不是 <math>\Omega\times2,\Omega^2,\varepsilon_{\Omega+1},\varphi(\Omega,1)</math> 之类的东西，而是远远在它们之上的存在。

再然后，还会有 <math>\Omega_3,\Omega_4,\dots,\Omega_{\omega+1},\dots,\Omega_{\Omega+1},\dots</math> 它们一同组成了容许序数的集合。

值得注意的是，上面一句话跳过了 <math>\Omega_\omega ,\Omega_\Omega</math>，而单独列出了 <math>\Omega_{\omega+1}</math> 和 <math>\Omega_{\Omega+1}</math>。这是因为 <math>\Omega_\omega</math> 和 <math>\Omega_\Omega</math> 并非容许序数——这一点可以通过“找长度小于它本身的基本列”来实现。

更进一步地，<math>\mathrm{OFP}=\psi_I(0)</math> 存在一条长度为 ω 的基本列 <math>\{\Omega,\Omega_\Omega,\Omega_{\Omega_{\Omega}},\dots\}</math>，它也是非容许的。

事实上，对于大多数的 <math>\Omega_\alpha</math>，其中 α 为极限序数， α 的基本列总是会成为我们我们的突破口，让我们找到 <math>\Omega_\alpha</math> 的一条长度小于自身的基本列。

顺便一提，对于所有的后继序数 α，<math>\Omega_\alpha</math> 都毫无疑问是容许序数。

==== <math>1-2,~(1-)^{1,0}~2</math> 等 ====
1-2 ，即取出集合 <math>2=\{\Omega,\Omega_2,\dots,\Omega_{\omega+1},\dots,\Omega_{\Omega+1},\dots\}</math> 中所有的极限点。

2 中的前 ω 个序数的上确界是 <math>\sup\{\Omega,\Omega_2,\dots\}=\Omega_\omega</math>，所以 <math>\Omega_\omega\in1-2</math>；

2 中的前 <math>\omega\times2</math> 个序数的上确界是 <math>\Omega_{\omega\times2}</math>，所以 <math>\Omega_{\omega\times2}\in1-2</math>……

如此一来， 1-2 就是“<math>\Omega_\alpha</math>，其中 α 为极限序数”的集合。需要注意的是，这样的序数大多数都是非容许的。这意味着 1-2 这个集合中的大部分元素甚至不属于 2 。我们对 2 这个集合进行了 <math>1~\mathrm{onto}</math> 的操作，得到了一个性质更差的集合，这种事在反射里，是相当常见的。

接着是 1-1-2 。我们取集合 1-2 的极限点，可以得到“<math>\Omega_\alpha</math>，其中 α 为 <math>\omega^2</math> 的倍数”的集合。同样地，我们可以通过取交集得到 <math>(1-)^\omega~2,~(1-)^{\omega^2}~2</math> 乃至 <math>(1-)^\Omega~2</math>。由于 <math>\Omega=\min~2</math>，所以 <math>(1-)^\Omega~2</math> 又可以写作 <math>(1-)^{(2)}~2</math> 。这里在上标上省略了 min ，并且在外面加了一层括号用以和序数 2 区分。

于是我们来到了 <math>(1-)^{1,0}~2</math>。类似 <math>(1-)^{1,0}</math> 的定义，<math>(1-)^{1,0}~2=\{\alpha|\alpha=(1-)^\alpha~2\}</math>。不难发现，<math>(1-)^{1,0}~2</math> 的每一个元素 α 都满足 <math>\alpha=\Omega_\alpha</math>，因此，<math>(1-)^{1,0}~2</math> 是全体 OFP 的集合。<math>\{\psi_I(0),\psi_I(1),\dots,\psi_I(\Omega),\dots,\psi_I(I),\dots\}</math>.

<math>(1-)^{1,0}~2</math> 过后，同样也有 <math>(1-)^{2,0}~2,~(1-)^{1,0,0}~2,\dots</math>。不过，不管 <math>(1-)^{a,b,c,\dots}~2</math> 的上标的层级多深，只要它还是不动点的形式，它就是非容许的。

=== 递归不可达序数 ===
''前排提示：关于 I 及多元 I 函数在 OCF 中的折叠规则，参见词条[[递归不可达序数]]''

我们不妨思考一下，若一个极限序数 α 足以使得 <math>\Omega_\alpha</math> 为容许序数的话，它需要满足什么条件呢？

首先，α 是容许序数；其次， <math>\alpha\in1-2</math> 。即满足上述条件的 α 属于 2 和 1-2 的交集，记为 <math>\alpha\in2~1-2</math>。

根据 [[ZFC公理体系|ZFC 公理体系]]，我们可以直接证明 2 和 1-2 的交集存在元素，我们将其命名为递归不可达序数。最小的递归不可达序数记作 I ，次小的是<math>I_2</math>……就和 <math>\Omega,\Omega_2</math>差不多。

总之，<math>2~1-2=\{I,I_2,\dots,I_{\omega+1},\dots,I_{I+1},\dots,I(1,0),\dots\}</math>。注意到这里也没有列出 <math>I_\omega</math> ，<math>I_\omega</math> 并非容许序数。

接下来，我们还可以对 2~1-2 进行若干次 1-，例如 <math>1-2~1-2=\{I_\omega,I_{\omega\times2},\dots,I_I,\dots,\mathrm{IFP},\dots\}</math>。推导过程和 1-2 是一致的，注意 1-2~1-2 表示的实际上是 <math>1~\mathrm{onto}~(2~1-2)</math>。

<math>(1-)^{1,0}~2~1-2</math> 自然是全体 IFP，也就是满足 <math>\alpha=I_\alpha</math>的序数构成的集合。

==== 容许点 ====
对“容许点”的定义，即：

序数 <math>\Theta</math> 为函数 <math>f(\alpha)</math> 的容许点，等同于 <math>\Theta</math> 是 <math>f(\alpha)</math> 的不动点且为容许序数。

于是我们可以看到，<math>\Omega</math> 是函数 <math>f(\alpha)=\omega^\alpha</math> 的容许点；I 是函数 <math>f(\alpha)=\Omega_\alpha</math> 的容许点。

更一般地，若函数 <math>f(\alpha)</math> 的值域是集合 A ，那么 <math>f(\alpha)</math> 的容许点组成的集合是 <math>2~1-A</math> 。

在更以后的地方，提到的某函数的“马洛点”“ K 点”等“ X 点”概念也都指代“某序数是 X 序数且是该函数的不动点”。

==== I(1,0) 等二元 I 函数 ====
函数 <math>f(\alpha)=I_\alpha</math> 的容许点是什么呢？认为是 M 的读者可能受到了 IMK 经常被一同提起的影响。实际上，函数<math>f(\alpha)=I_\alpha</math>的最小的容许点仅仅是 I(1,0) 。受到《大数入门》的影响，部分读者会认为 I(1,0) 与 IFP 等同，实则并非如此。

根据前面提到的“若函数 <math>f(\alpha)</math> 的值域是集合 A ，那么 <math>f(\alpha)</math> 的容许点组成的集合是 <math>2~1-A</math> 。”的规则，不难知道，函数 <math>f(\alpha)=I_\alpha</math> 的全体容许点的集合是 <math>2~1-2~1-2</math>。

<math>f(\alpha)=I_\alpha</math> 的次小的容许点是 I(1,1) 。这里，二元 I 的最后一位实质上相当于 <math>\Omega</math> 或者 I 的下标。于是，<math>(2~1-)^2~2=2~1-2~1-2=\{I(1,0),I(1,1),\dots,I(1,\omega+1),\dots\}</math> 。 <math>I(1,\omega)</math> 同样是非容许的。

<math>(1-)^{1,0}~2~1-2~1-2</math> 是函数 <math>f(\alpha)=I(1,\alpha)</math>的不动点，记作 <math>I(1,a)\mathrm{FP}</math> 。最小的 <math>I(1,a)\mathrm{FP}</math>也并非 I(2,0) 。 I(2,0) 是函数 <math>f(\alpha)=I(1,\alpha)</math> 的容许点。多元 I 函数的这种进位方式，称为'''容许点进位'''。

……

像这样继续往前，自然会遇到 <math>(2~1-)^\omega~2</math>，我们期望它是 <math>\{I(\omega,0),I(\omega,1),\dots\}</math>。如果我们仍用定义 <math>(1-)^\omega</math> 时的交集来定义它会怎么样呢？下面才会真正开始涉及真伪的争端……

==== psd. 和 real. ====
<math>I(\omega,\alpha)</math> 的定义方式与 <math>\varphi(\omega,\alpha)</math> 是类似的。即：

<math>I(\omega,0)=\sup\{I(n,0)|n\in\mathbb{N}\}</math>

<math>I(\omega,\alpha)=\sup\{I(n,I(\omega,\alpha-1)+1)|n\in\mathbb{N}\}(\alpha\text{为后继序数})</math>

<math>I(\omega,\alpha)=\sup\{I(\omega,\beta)|\beta<\alpha\}(\alpha\text{为极限序数})</math>

这意味着 <math>\alpha=0</math> 以及 α 为后继序数时，<math>I(\omega,\alpha)</math> 都存在一条长度为 ω 的基本列，这使得 <math>I(\omega,\alpha)</math> 非容许。这与前面的 <math>I(n,\alpha)</math> 的性质是截然相反的。最小的同时满足“ α 是极限序数”和“ <math>I(\omega,\alpha)</math> 容许”的序数是函数 <math>f(\alpha)=I(\omega,\alpha)</math> 的容许点，记作 <math>I(\omega+1,0)</math>。

对于 <math>I(\omega\times2,\alpha),I(\omega^2,\alpha)</math> 等“高位为极限序数的二元 I 函数”的情形，都可以像这样定义。对于绝大多数极限序数 β 和后继序数 α，<math>I(\beta,\alpha)</math> 都不是容许序数。

==== <math>real.(2\ 1-)^\omega\ 2</math> ====
对于使用交集定义的 <math>(2~1-)^\omega~2</math>，一般称作 <math>real.(2~1-)^\omega~2</math>。即 <math>real.(2~1-)^\omega~2=\bigcap_{n<\omega}(2~1-)^n~2</math>

现在让我们思考一下一个序数如果要是 <math>real.(2~1-)^\omega~2</math>，它需要具备哪些性质。根据上面的结论，我们可以推出：

<math>\alpha\in real.(2~1-)^\omega~2\Leftrightarrow\alpha</math> 为容许序数 <math>\wedge\alpha\text{为}f,g,h_1,\ldots</math> 等函数的不动点

首先关注后面的条件。利用类似 Veblen 函数的“闭包”机制，可以证明，α 为这些函数的不动点等同于 <math>\alpha=I(\omega,\beta)</math>。那么，整个条件就变为了“α 是 <math>I(\omega,\cdot)</math> 序数且 <math>\alpha</math> 为容许序数”。这正是我们要刻画的 <math>real.(2~1-)^\omega~2</math> 的模样。

==== <math>real.(2~1-)^\omega~2</math> ====
像这样直接跳过 <math>I(\omega,\alpha)</math> 一族序数似乎不太好。我们希望能有一个简单的反射式子来表示它们，并且最好这个简单的式子就是 <math>(2~1-)^\omega~2</math>。这就引出了下面的 <math>psd.(2~1-)^\omega~2</math> 的定义：

<math>A~\mathrm{aft}~X=\sup\{2~\mathrm{aft}~X,~2~1-2~\mathrm{aft}~X,~(2~1-)^2~2~\mathrm{aft}~X,\ldots\} </math> 

<math>psd.(2~1-)^\omega~2=A\cup1-A</math>

定义完了 <math>psd.(2~1-)^\omega~2</math> 之后，我们会发现 <math>real.(2~1-)^\omega~2</math> 实际上就是 <math>2~1-psd.(2~1-)^\omega~2=psd.(2~1-)^{\omega+1}~2</math>。如此一来就建立了 psd. 和 real. 的联系。

重要：psd. 和 real. 的形式类似、性质则相当不同，容易引起不必要的争端。因此，本条目在之后提及 <math>(2~1-)^\omega~2</math> 和类似的 <math>(2-2~1-)^\omega~2-2 , (2-)^\omega</math> 等序数时，若不使用前缀，则默认为 psd. 定义。因此，可以直接写 <math>real.(2~1-)^\omega~2=2~1-(2~1-)^\omega~2=(2~1-)^{\omega+1}~2</math>。

==== 多元 I 函数 ====
顺着 <math>I(\omega+1,0)</math> 继续往上，使用容许点进位的规则和 psd. 定义，有：

<math>I(\omega+2,0)</math> 是 <math>f(\alpha)=I(\omega+1,\alpha)</math> 的最小的容许点， <math>(2~1-)^{\omega+2}~2=\{I(\omega+2,0),I(\omega+2,1),\ldots,I(\omega+2,\omega+1),\ldots\}</math>；

<math>I(\omega+3,0)</math> 是 <math>f(\alpha)=I(\omega+2,\alpha)</math> 的最小的容许点，<math>(2~1-)^{\omega+3}~2=\{I(\omega+3,0),I(\omega+3,1),\ldots,I(\omega+3,\omega+1),\ldots\}</math>；

<math>(2~1-)^{\omega\times2}~2</math> 是全体 <math>I(\omega\times2,\cdot)</math> 序数。 <math>real.(2~1-)^{\omega\times2}~2=(2~1-)^{\omega\times2+1}~2</math> ；

……

像这样，我们可以确定任意的 <math>(2~1-)^\alpha~2~(\alpha>\omega)</math>的景象。当 α 为后继序数时，<math>(2~1-)^\alpha~2</math> 是全体<math>I(\alpha,\cdot)</math> 序数中的容许序数；当 α 为极限序数时，<math>(2~1-)^\alpha</math> 就是全体 <math>I(\alpha,\cdot)</math> 序数。

上标增加到一定程度，自然就会出现不动点。与 <math>(1-)^{1,0}</math> 类似地，我们把满足 <math>\alpha=\min~(2~1-)^\alpha~2</math> 的序数集合记作 <math>(2~1-)^{1,0}~2</math>。

我们可以像这样用二元 I 函数来表示它 ：<math>(2~1-)^{1,0}~2=\{\alpha|\alpha=I(\alpha,0)\}</math>

即 <math>(2~1-)^{1,0}~2</math> 是全体 <math>\alpha\to I(\alpha,0)</math> 的不动点。最小的这样的不动点该如何用多元 I 表示？ I(1,0,0) 吗？不要忘了 I 的容许点进位规则。它应该是 <math>\psi_{I(1,0,0)}(0)</math> 。次大的不动点自然就是<math>\psi_{I(1,0,0)}(1)</math>了。所以，有：

<math>(2~1-)^{1,0}~2=\{\psi_{I(1,0,0)}(0),\psi_{I(1,0,0)}(1),\dots,\psi_{I(1,0,0)}(\omega),\dots,I(1,0,0),\dots\}</math>

<math>(2~1-)^{1,1}~2=2~1-(2~1-)^{1,0}~2</math> 是函数 <math>f(\alpha)=\psi_{I(1,0,0)}(\alpha)</math> 的容许点，也就是全体 <math>I(1,0,\cdot)</math>序数中的容许序数。在这里，'''<math>2~1-</math> 的强度借助不动点，有了一个提升'''。

后面的多元 I 并没有新的附加规则，只需要牢记容许点进位即可。如

<math>(2~1-)^{1,2}~2=\{I(1,1,0),I(1,1,1),\dots,I(1,1,\omega+1),\dots,I(1,2,0),\dots\}</math>

<math>(2~1-)^{2,1}~2=\{I(2,0,0),I(2,0,1),\dots,I(2,0,\omega+1),\dots,I(2,1,0),\dots\}</math>

<math>(2~1-)^{1,0,0,1}~2=\{I(1,0,0,0,0),I(1,0,0,0,1),\dots,I(1,0,0,0,\omega+1),\dots,I(1,0,0,1,0),\dots\}</math>

……

=== 递归马洛序数 ===
''前排提示：关于 M 在 OCF 中的折叠规则，参见词条[[递归 Mahlo 序数]]''

进一步增加 <math>2~1-</math> 的上标的深度之后，我们会被一道新的不可逾越之壁所阻挡。正如同 <math>\Omega=\min~2</math> 无法通过单纯的 1- 操作得到一样， <math>M=\min~2-2</math> 也无法通过单纯的 <math>2~1-</math> 操作得到。我们把这样的 M 称作递归马洛序数。

递归马洛序数有无穷多个。我们把第二个，第三个……递归马洛序数分别记为 <math>M_2,M_3,\dots</math>，就像这样：<math>2-2=\{M,M_2,M_3,\dots,M_{\omega+1},\dots\}</math>

当然了，<math>M_\omega</math> 也不是递归马洛序数。它甚至不是容许序数——所有的递归马洛序数都是容许序数。

对递归马洛序数的集合进行 1- 反射，可以得到：

<math>1-2-2=\{M_\omega,M_{\omega\times2},\dots,M_{\omega^2},\dots,M_M,\dots\}</math>

即 1-2-2 是全体 “<math>M_\alpha</math>，其中 α 为极限序数”所构成的集合。自然地，我们有 <math>(1-)^{1,0}~2-2</math>。根据定义，它是全体满足 <math>\alpha=\min~(1-)^\alpha~2-2</math> 的集合，也就是 MFP ，函数 <math>f(\alpha)=M_\alpha</math> 的不动点。

那么，函数 <math>f(\alpha)=M_\alpha</math> 的容许点又如何呢？根据前文所讲的容许点的性质，可以知道，这个函数的全体容许点构成了集合 <math>2~1-2-2</math>。后面 <math>(2~1-)^{a,b,c,\dots}~2-2</math>类似前文所述的多元 I 函数，这里不再赘述。

==== <math>2-2~1-2-2</math> ====
接下来，会有一个序数能折叠 <math>(2~1-)^{a,b,c,\dots}~2-2</math>。也就是，任意深度的 <math>(2~1-)</math> 操作到 2-2 这个集合上，都得不到它。这个序数就是 <math>2-2~1-2-2</math> ，即 <math>2~\mathrm{onto}~2~1-2-2</math>。

还可以更深入地了解一下 <math>2-2~1-2-2</math> 这个大序数的性质。暂时把它记作 X 吧。

首先， X 要能折叠 <math>(2~1-)</math> 操作，所以它至少要是递归马洛序数，即 <math>X\in2-2</math>；

然后，需要考虑一下这样的 X 相对于普通的递归马洛序数有哪些不同之处。 X 能折叠出函数 <math>f(\alpha)=M_\alpha</math> 的容许点，而这些容许点有什么特性呢？回到容许点的定义，可以知道，这些容许点都是 <math>f(\alpha)=M_\alpha</math> 的不动点，也即 <math>\mathrm{MFP}=(1-)^{1,0}~2-2</math>。

所有的 <math>(1-)^{1,0}~2-2</math> 自然也是 1-2-2 。那么，就得到了 <math>2-2~1-2-2</math> 同时是 2-2 和 1-2-2 的结论。更进一步的证明显示，<math>2-2~1-2-2</math> 与 <math>2-2~\cap~1-2-2</math> 等价——这可不是一句无意义的废话。我们对 <math>2-2~1-2-2</math> 的定义实际上是 <math>2-(2~1-2-2)</math>，这里证明了交集和最左侧的 onto 运算次序可以交换。

我们称这样既是递归马洛序数，又是函数 <math>f(\alpha)</math> 不动点的序数，称为该函数的 '''M 点'''。

=== 更深的反射 ===
''tips：这里的任意深度可以理解为，你有一个强度穷尽所有递归序数的扩展 Veblen 函数，这里你的上标则拥有任意强度的你的扩展 Veblen。''

可以对 <math>2-2~1-2-2</math> 继续进行 1- 和 <math>2~1-</math> 操作，得到更大的序数。同样地，我们会有 <math>(2~1-)^{1,0,0}~1-2-2~1-2-2</math>，<math>(2~1-)^{1,0,0,0}~1-2-2~1-2-2</math>，以及折叠它们的 <math>2-2~1-2-2~1-2-2</math>。<math>2-2~1-2-2~1-2-2</math> 也等同于 <math>2-2~\cap~1-2-2~1-2-2</math>。我们可以对其不断进行 <math>2-2~1-</math> 操作。

<math>2-2~1-</math> 操作的上标也可以进一步加深。自然地，有一个大序数折叠它。这就是 2-2-2 ，我们将其称为不可转换序数，记作 N。即：

<math>2-2-2=\{N,N_2,\dots,N_{\omega+1},\dots\}</math>

<math>2-2-2~\text{折叠}~(2-2~1-)^{a,b,c,\dots}</math>

类似的，<math>2-2-2~1-2-2-2</math> 是函数 <math>f(\alpha)=N_\alpha</math>的N点。

在 <math>2-2-2~1-2-2-2</math> 之后，又可以加深 <math>2-2-2~1-</math> 操作的层级，并引入一个更大的序数折叠这一操作。这样得到的就是 2-2-2-2 了。这个序数过于“不整”，以至于它并没有一个专有的名字和符号。

到这里，足以勾勒出一个对 <math>2~\mathrm{onto}</math> 的印象了。我们可以这样理解 <math>2~\mathrm{onto}</math> 集合 X 的行为：

<math>2~\mathrm{onto}~X</math> 是对 <math>(X~\cap~1-)</math> 的折叠。

可以发现，这个集合 X 越强，<math>2~\mathrm{onto}</math> 所折叠的操作也越强。而反过来，如果这个 X 本身性质不够好的话，也会“连累”<math>2~\mathrm{onto}</math> 的强度一起变弱。

那么，通往 2-2-2-2-2 的路也明确了。类似地，还能继续得到 <math>(2-)^6,(2-)^7,\dots</math>，直至 <math>(2-)^\omega</math>。这里的 <math>(2-)^\omega</math> 也使用 psd. 定义，即

<math>\min~(2-)^\omega=\sup\{2,~2-2,~2-2-2,\dots\}</math>

而 <math>real.~(2-)^\omega</math> 是理想状态的 <math>(2-)^{\omega+1}</math>。思路和 <math>real.~(2~1-)^\omega~2=psd.~(2~1-)^{\omega+1}~2</math> 是类似的。

注意：在 <math>real.(2-)^\omega</math> 这里实际上存在一个大坑。正如前文所说的，当 X 的性质不够好的时候，会“连累”<math>2~\mathrm{onto}~X</math> 一起变弱。而这里的 <math>(2-)^\omega</math> 就是一个性质不够好的集合。这使得 <math>2~\mathrm{onto}~(2-)^\omega</math> 其实很弱，并不是 <math>real.~(2-)^\omega</math>。不过，我们仍可以通过另一种思路得到它 。即定义“<math>(2-)^\omega</math> 点”为 sup{不动点，容许点，M 点，N 点，……}，那么 <math>real.(2-)^\omega</math> 折叠“取 <math>(2-)^\omega</math> 点”的操作。不过，出于书写符号的方便，仍把 <math>real.(2-)^\omega</math> 记作 <math>(2-)^{\omega+1}</math>。

==== <math>(2-)^{1,0}</math> 等 ====
现在，可以对它们进行 2- 反射以继续前进了。也就是：

<math>(2-)^{\omega+2}</math> 折叠任意深度的 <math>((2-)^{\omega+1}~1-)^{a,b,c,\dots}~(2-)^{\omega+1}</math>

<math>\min~(2-)^{\omega\times2}=\sup\{\min~(2-)^{\omega+1},\min~(2-)^{\omega+2},\min~(2-)^{\omega+3},\dots\}</math>

<math>(2-)^{\omega\times2+1}=real.(2-)^{\omega\times2}</math> 折叠“取 <math>(2-)^{\omega\times2}</math> 点”的操作。

上标上的序数可以一直增加，每次经过极限序数的时候都会碰到一点关于 psd. 和 real. 的破事。不过，对于不想搭理这些破事的读者，记住 psd. 规则和“real. 相当于 +1”就已经足够了。

接下来，还会有 <math>(2-)^\Omega=(2-)^{(2)}</math>，<math>(2-)^M=(2-)^{(2-2)}</math>，以及 <math>(2-)^{(2-)^\omega}</math>和 <math>(2-)^{(2-)^{(2-)^\omega}}</math>……这样做的极限就是 <math>(2-)^{1,0}</math>了。

注意到上一句话的用词是“极限”而不是“不动点”。这样用词是因为这里也有 <math>psd.~vs.~real.</math> 的定义问题。对于 <math>(2-)^{1,0}</math>，有如下定义：

<math>\alpha\in psd.(2-)^{1,0}\Leftrightarrow \forall\beta<\alpha,\exists\gamma\in(2-)^\beta,\gamma<\alpha</math>

<math>\alpha\in real.(2-)^{1,0}\Leftrightarrow\forall\beta<\alpha,\alpha\in(2-)^\beta</math>

简而言之，<math>psd.(2-)^{1,0}</math> 只要求对于所有 <math>\beta<\alpha</math> ，在 α 的下方都存在一个 <math>(2-)^\beta</math> 的序数，对 α 自身的性质未作出要求；而 <math>real.(2-)^{1,0}</math> 要求 α 自身就是 <math>(2-)^\beta</math> 序数。

<math>psd.(2-)^{1,0}</math> 显然不是容许序数。可以用类似 OFP 的方式为它找到一条长度为 ω 的递归基本列。

不想搭理破事的读者依旧可以把 <math>real.(2-)^{1,0}</math> 理解为 <math>(2-)^{1,1}</math>，它折叠“取 <math>(2-)^{1,0}</math> 点”的操作。这里就不展开细说了。

然后，是 <math>2-(2-)^{1,1}=(2-)^{1,2},(2-)^{1,\omega},(2-)^{1,\Omega},\dots</math> 以及这样做的极限 <math>(2-)^{2,0}</math>。上标的规则没什么变化。进一步加深上标，就会得到 <math>(2-)^{1,0,0}</math> 之类的东西。

是时候，把这些恼人的上标也送去折叠了。

==== 递归弱紧致序数 ====
折叠 2- 操作的序数称为递归弱紧致序数，写作 K 。全体递归弱紧致序数构成的集合也是 <math>\Pi_3</math> 反射作用于全体序数得到的集合，在反射模式中记作 3 。即 <math>3~\text{折叠}(2-)^{a,b,c,\dots}=\{K,K_2,K_3,\dots,K_{\omega+1},\dots\}</math>

所有的递归弱紧致序数，都同时是容许序数、递归不可达序数、递归马洛序数、不可转换序数……等等等等。

可以对 3 这个集合施加<math>\Pi_1</math>、 <math>\Pi_2</math>反射操作，继续枚举：

<math>1-3=\{K_\omega,K_{\omega\times2},\dots,K_\Omega,\dots,K_K,\dots\}</math>。<math>(1-)^{1,0}~3</math> 是所谓的 KFP 构成的集合。<math>2~1-3</math> 是函数 <math>f(\alpha)=K_\alpha</math> 的容许点。<math>2-2~1-3</math> 折叠任意深度的 <math>(2~1-)^{a,b,c,\dots}~3</math>，它们也是函数<math>f(\alpha)=K_\alpha</math> 的马洛点。<math>2-2-2~1-3</math> 折叠任意深度的<math>(2-2~1-)^{a,b,c,\dots}~3</math>，它们也是函数 <math>f(\alpha)=K_\alpha</math> 的 N 点。<math>(2-)^{1,0}~1-3</math> 是满足“对于任意 <math>\beta<\alpha</math>，都存在 <math>\gamma\in(2-)^\beta~1-3</math> 使得 <math>\gamma<\alpha</math>”的全体序数 α 构成的集合，它也是集合 <math>(2-)^{1,0}</math> 与集合 1-3 的交集。

<math>3~1-3</math> 是集合 3 与集合 1-3 的交集，折叠任意深度的 <math>(2-)^{a,b,c,\dots}~1-3</math>。与 <math>2~1-2</math> 类似，它也可以被理解为全体“足以使得 <math>K_\alpha</math> 是递归弱紧致序数的极限序数 α”所构成的集合，以及函数 <math>f(\alpha)=K_\alpha</math> 的 K 点。

从 3 到 <math>3~1-3</math> ，我们相当于把从 Ord 到 3 的路又走了一遍。

再走第二遍的话，我们就会路过 <math>2~1-3~1-3,~2-2~1-3~1-3,~(2-)^{1,0}~1-3~1-3,\dots</math>，最终到达 <math>3~1-3~1-3=(3~1-)^2~3</math>。再走第三遍，到达 <math>(3~1-)^3~3</math>。

花吃奶的劲突破超限序数，到达 <math>(3~1-)^{1,0}~3</math>。

而 2-3 可以折叠任意深度的 <math>(3~1-)^{a,b,c,\dots}~3</math>。正如我们上一篇所说的， 2-X 折叠 <math>(X~\cap~1-)</math> 的操作。 X 本身强得可怕的时候， 2-X 就会更加强得可怕。

以上，还只是 <math>\Pi_3</math> 反射能形成的丰富结构中最靠前的一部分。

==== 从 <math>2-3</math> 到 <math>3~2-3</math> 再到 <math>(3~2-)^{a,b,c,\dots}~3</math> ====
继续构造一个函数 <math>f(\alpha)</math> 用来表示“第 α 个 2-3 ”，然后继续前进。中间又会经过 <math>2~1-2-3,~2-2~1-2-3,~(2-)^{1,0}~1-2-3</math>，而 <math>3~1-2-3</math> 是这个函数的 K 点。

然后，是 <math>(3~1-)^2~2-3,(3~1-)^\omega~2-3 ,(3~1-)^{1,0}~2-3</math> 之类的东西。

什么折叠任意深度的 <math>(3~1-)^{a,b,c,\dots}~2-3</math> 呢？注意到从 2-3 到这里的过程相当于从 Ord 到 2-3 ，所以它应该是 <math>2-3~1-2-3</math>，也就是 <math>f(\alpha)</math> 的 2-3 点。

利用“取 2-3 点”的操作，又可以有 <math>2-3~1-2-3~1-2-3=(2-3~1-)^2~2-3,(2-3~1-)^\omega~2-3,(2-3~1-)^{1,0}~2-3</math> 等等。

在这之后， 2-2-3 能折叠任意深度的 <math>(2-3~1-)^{a,b,c,\dots}~2-3</math>，也就是“取 2-3 点”这么一个操作。

2-2-2-3 折叠任意深度的 <math>(2-2-3~1-)^{a,b,c,\dots}~2-2-3</math>。这一部分和前面的 2-2-2 没什么不同，只是底层由“ 1- 反射”变为了“<math>3~1-</math> 操作”。直到 <math>(2-)^\omega~3</math>。

<math>(2-)^{1,0}~3</math>。在它下面的每一个 β ，都存在一个 <math>(2-)^\beta~3</math> 序数小于它。

接下来考虑一个能折叠任意深度的 <math>(2-)^{a,b,c,\dots}~3</math> 的序数。这个序数能折叠 2- 的操作，所以是一个 <math>\Pi_3</math> 序数；同时，它又至少是 2-3。因此，这个序数至少是 3 和 2-3 的交集。依旧可以证明，这个条件已经足够了。也就是 <math>{3~2-3\text{折叠}(2-)^{a,b,c,\dots}~3}</math>。

<math>2~1-3~2-3</math>，这是“计数 <math>3~2-3</math> 的函数”的容许点。

<math>2-2~1-3~2-3</math>，这是“计数<math>3~2-3</math> 的函数”的马洛点。

<math>3~1-3~2-3</math>，这是“计数 <math>3~2-3</math> 的函数”的 K 点。

……

<math>2-3~1-3~2-3</math> 折叠任意深度的 <math>(3~1-)^{a,b,c,\dots}~2-3</math>。这里是一个易错点。根据前面提到的“2-3 折叠<math>(3~1-)^{a,b,c,\dots}</math>”可以知道。折叠 <math>(3~1-)^{a,b,c,\dots}~2-3</math> 的应该是“计数 <math>3~2-3</math> 的函数”的 2-3 点，也就是 <math>{\color{red}{2-3~1-}}~3~2-3</math>，而并非 <math>2-3~2-3</math>。

<math>2-3~1-2-3~1-3~2-3=(2-3~1-)^2~3~2-3</math>。

<math>2-2-3~1-3~2-3</math> 折叠任意深度的 <math>(2-3~1-)^{a,b,c,\dots}~3~2-3</math>。

……

然后，有 <math>3~2-3~1-3~2-3</math> 折叠任意深度的 <math>(2-)^{a,b,c,\dots}~3~1-3~2-3</math>。它是“计数 <math>3~2-3</math> 的函数”的 <math>3~2-3</math> 点。这是我们第一次在“XX 点”的概念中涉及到交集。<math>2-3~2-3</math> 要折叠的正是这个“取 <math>3~2-3</math> 点”的概念。

再取一次 <math>3~2-3</math> 点看看。<math>3~1-3~2-3~1-3~2-3</math>。

<math>2-3~1-3~2-3~1-3~2-3</math> 折叠任意深度的 <math>(3~1-)^{a,b,c,\dots}~3~2-3~1-3~2-3</math>。<math>2-2-3~1-3~2-3~1-3~2-3</math> 折叠任意深度的 <math>(2-3~1-)^{a,b,c,\dots}~3~2-3~1-3~2-3</math>。<math>3~2-3~1-3~2-3~1-3~2-3=(3~2-3~1-)^2~3~2-3</math> 折叠任意深度的 <math>(2-)^{a,b,c,\dots}~3~1-3~2-3~1-3~2-3</math>。再才有 <math>2-3~2-3</math> 折叠任意深度的 <math>(3~2-3~1-)^{a,b,c,\dots}~3~2-3</math>。<math>2-3~2-3~1-2-3~2-3</math> 是“计数 <math>2-3~2-3</math> 的函数”的 <math>2-3~2-3</math> 点。<math>2-2-3~2-3</math> 折叠任意深度的 <math>(2-3~2-3~1-)^{a,b,c,\dots}~2-3~2-3</math>。<math>3~2-3~2-3</math> 折叠任意深度的 <math>(2-)^{a,b,c,\dots}~3~2-3</math>。<math>2-3~2-3~2-3</math> 折叠任意深度的 <math>(3~2-3~2-3~1-)^{a,b,c,\dots}~3~2-3~2-3</math>。

稍微理一下这一段的逻辑：我们对一个表达式不断地进行 2- 的操作，折叠 2- 操作的是最前面有个“3 ”（注意空格）的表达式；然后对这个有“3 ”的表达式再不断进行 2- 操作，再折叠它……最终形成一条 <math>\cdots3~2-3~2-3~2-3</math> 的链条。每一次最基础的 2- 操作，都要折叠一次“取自己点”的操作。好一个折叠再折叠。

延伸这个链条到超限序数，就能看到 <math>(3~2-)^\omega~3</math>还有<math>(3~2-)^{1,0}~3</math> 。

现在，终于可以打开 <math>3~\mathrm{onto}</math> 的大门了。<math>3~\mathrm{onto}</math> 集合 X 的行为实际上与 <math>2~\mathrm{onto}~X</math> 很像。我们有 <math>3~\mathrm{onto~}X</math>是对 <math>(X~\cap~2-)</math> 的折叠。

更进一步地，我们可以给出 <math>k~\mathrm{onto}~X (k\geq2)</math> 的行为：<math>k~\mathrm{onto}~X</math> 是对 <math>(X~\cap~(k-1)-)</math> 的折叠。

理论上，现在我们畅通无阻、直通 <math>\Pi_\omega</math> 了。

== 反射式的展开操作规则 ==
是否存在一套简单的规律以便我们判断某一个反射式折叠了什么操作？答案是肯定的。并且这一规律奇妙地与 [[初等序列系统|PrSS]] 存在联系。具体操作分为以下几步：

第一步，替换。把反射式中间的空格和 - 都替换为逗号，然后倒序排列。例如 <math>2-4~2-3-4</math> 先变为 2,4,2,3,4 ，再倒序排列为 4,3,2,4,2 ；

第二步，补项。若第一项为 k ，在前面补上 <math>1,2,\dots,k-1</math>；若式子中后一项减前一项的差 >1，也在中间补上连续自然数，使得任意一项都不超过前一项 +1 ，这样，序列就变为了一个标准的 PrSS 序列。补上的项需要做好标记。上一步得到的 4,3,2,4,2 在这里补项为 <math>{\color{red}{1,2,3}},4,3,2,\color{red}3,4,2</math>；

第三步，展开。按照 PrSS 规则展开序列，复制坏部的时候需要连标记一并复制，但坏根除外。上一步的结果在这里展开为 <math>1,2,3,4,3,2,3,4,(1,2,3,4,3,2,3,4),(1,2,3,4,3,2,3,4),(1,2,3,4,3,2,3,4),\dots</math>；

最后一步，还原。去掉被标记的项，倒序回来，将逗号还原为空格和 -，此时的结果就是原来的反射式要折叠的结构。上一步的展开结果还原为 <math>\cdots(4~2-3-4~1-)(4~2-3-4~1-)(4~2-3-4~1-)4~2-3-4</math>，即 <math>(4~2-3-4~1-)^{a,b,c,\dots}~4~2-3-4</math>。

于是我们得到：<math>2-4~2-3-4</math> 折叠任意深度的 <math>(4~2-3-4~1-)^{a,b,c,\dots}4~2-3-4</math>。

{{默认排序:非递归记号}}
[[分类:记号]]