打开/关闭菜单
打开/关闭外观设置菜单
打开/关闭个人菜单
未登录
未登录用户的IP地址会在进行任意编辑后公开展示。

反射序数:修订间差异

来自Googology Wiki
Z留言 | 贡献
无编辑摘要
Tabelog留言 | 贡献
文字替换 -“weak Veblen 函数”替换为“weak Veblen 函数
 
(未显示2个用户的9个中间版本)
第4行: 第4行:
''前排提醒:对数学定义不感冒或者看不懂的读者可以跳到后面''
''前排提醒:对数学定义不感冒或者看不懂的读者可以跳到后面''


为了说明反射序数的性质,我们先要对[[一阶逻辑]]的结构进行更加细致的讨论。下面我们根据命题中无界量词的性质,给出公式的层次:
根据命题中无界量词的性质,给出公式的层次:


满足如下条件之一的集合论公式称为<math>\Delta_0</math>公式
满足如下条件之一的集合论公式称为 <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>\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>(\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>\Delta_0</math> 公式中的所有量词都是有界的。


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


# <math>\Sigma_0</math>公式及<math>\Pi_0</math>公式为<math>\Delta_0</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>\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>公式。
# 如果 <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>.
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>
 
<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>序数。


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


α是X上的<math>\Pi_n</math>反射序数,等价于α是X上的<math>\Sigma_{n+1}</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 上的极限点
也就是说,我们只需要研究集合上的<math>\Pi_n</math>反射序数即可。进一步的有
* α 是 X 上的 <math>\Pi_2</math> 反射序数,等价于 α 是 X 上的容许序数


α是X上的<math>\Pi_0</math>反射序数,等价于α是X上的<math>\Pi_1</math>反射序数,等价于α是X上的极限点。
注:在一些资料中,会出现 <math>\Pi_0</math> 反射等价于全体序数的说法。这是错误的。事实上,如果我们想要写出全体序数,应该写出 <math>\bold{Ord}</math>(或 <math>\bold{On}</math>
 
在一些资料中,会出现<math>\Pi_0</math>反射等价于全体序数的说法。这是错误的。事实上,如果我们想要写出全体序数,应该写出<math>Ord</math>
 
我们还有结论:α是X上的<math>\Pi_2</math>反射序数,等价于α是X上的容许序数。


== 结构讲解 ==
== 结构讲解 ==
第47行: 第39行:


==== onto ====
==== onto ====
onto 是反射模式的核心。它的作用对象是一个集合,同时也输出一个集合。例如: <math>\Pi_1\ \mathrm{onto}</math>全体序数,得到的是全体极限序数构成的集合;<math>\Pi_2\ \mathrm{onto}</math>全体序数构成的集合,得到的是全体容许序数构成的集合。
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}</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>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{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>之类的“第超限序数个”的表达。
反射模式研究的集合中的元素都是序数。因此,我们可以把这些序数从小到大进行排序,并用 <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 ====
==== aft ====
将序数从小到大排序,排在后面的就是更大的序数。因此, <math>A\ \mathrm{aft}\ B</math>表示“集合 A 中大于序数 B 的元素”。将这一表达与<math>\min,\ \mathrm{2nd},\ \mathrm{3rd}</math>等结合起来,可以得到<math>\min\ A\mathrm{\ aft}\ B</math>(可直接简写为<math>\min\ A\mathrm{\ aft}\ B</math>)、 <math>2\mathrm{nd}\ A\mathrm{\ aft}\ B</math>等,分别表示“集合 A 中最小的大于序数 B 的元素”和“集合 A 中第二个大于序数 B 的元素”。
将序数从小到大排序,排在后面的就是更大的序数。因此, <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>反射 ===
=== <math>\Pi_1</math> 反射 ===


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


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


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


前ω个序数的上确界为ω,前<math>\omega\times2</math>个序数的上确界为<math>\omega\times2</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>\{\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> 的倍数的集合。
类似地, 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> 的倍数的集合。


继续递推,还能得到
继续递推,还能得到
第81行: 第75行:
<math>1-1-1-1=\{\omega^4,\omega^4\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> ====
==== <math>(1-)^\omega</math> ====
第88行: 第82行:
但,<math>(1-)^\omega</math>呢?
但,<math>(1-)^\omega</math>呢?


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


==== <math>(1-)^{1,0}</math>等 ====
==== <math>(1-)^{1,0}</math> 等 ====
上标只能放序数的情形是简单的,一个“<math>\omega^\alpha</math>的倍数”就直接解决了。如何让情形变得更有趣呢?我们可以借用[[veblen函数]]的不动点进位模式,在上标上引入多个数字,来表示不同层级的不动点。
上标只能放序数的情形是简单的,一个“<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}=\{\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>。
可以继续对 <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> 。在上标遇到极限序数时,我们也仍取交集。
更一般地,我们在上标上使用 [[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>等等并且还能在此基础上进行扩展。理论上,只要扩展足够强力,所有的递归序数都能像这样被表示出来。
直到我们遇见了新的不动点。我们定义 <math>(1-)^{2,0}=\{\alpha|\alpha=\min\ (1-)^{1,\alpha}\}</math>。借用 Veblen 函数的模式,我们还能把定义推广到 <math>(1-)^{1,0,0}</math> 等等并且还能在此基础上进行扩展。理论上,只要扩展足够强力,所有的递归序数都能像这样被表示出来。


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


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


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


最小的容许序数是Church-Kleene序数,记为<math>\omega_1^{CK}</math>,在这里我们把它写作<math>\Omega</math> ——没错,就是在OCF中出现的那个。
最小的容许序数是 [[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_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_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>\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>\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>\Omega_\alpha</math> 的一条长度小于自身的基本列。


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


==== <math>1-2,~(1-)^{1,0}~2</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>中所有的极限点。
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>\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>……
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-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 区分。
接着是 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-)^{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>的上标的层级多深,只要它还是不动点的形式,它就是非容许的。
<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中的折叠规则,参见词条[[多元I函数]]''
''前排提示:关于 I 及多元 I 函数在 OCF 中的折叠规则,参见词条[[递归不可达序数]]''


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


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


根据[[ZFC公理体系]],我们可以直接证明 2 和 1-2 的交集存在元素,我们将其命名为递归不可达序数。最小的递归不可达序数记作 I ,次小的是<math>I_2</math>……就和 <math>\Omega,\Omega_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> 并非容许序数。
总之,<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>。
接下来,我们还可以对 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>(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>\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>\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> 。
更一般地,若函数 <math>f(\alpha)</math> 的值域是集合 A ,那么 <math>f(\alpha)</math> 的容许点组成的集合是 <math>2~1-A</math> 。


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


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


==== psd.和real. ====
==== psd. 和 real. ====
<math>I(\omega,\alpha)</math>的定义方式与 <math>\varphi(\omega,\alpha)</math>是类似的。即:
<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,0)=\sup\{I(n,0)|n\in\mathbb{N}\}</math>
第189行: 第183行:
<math>I(\omega,\alpha)=\sup\{I(\omega,\beta)|\beta<\alpha\}(\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>\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>I(\omega\times2,\alpha),I(\omega^2,\alpha)</math> 等“高位为极限序数的二元 I 函数”的情形,都可以像这样定义。对于绝大多数极限序数 β 和后继序数 α,<math>I(\beta,\alpha)</math> 都不是容许序数。


==== <math>real.(2\ 1-)^\omega\ 2</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>(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>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>等函数的不动点
<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>的模样。
首先关注后面的条件。利用类似 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>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>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>A~\mathrm{aft}~X=\sup\{2~\mathrm{aft}~X,~2~1-2~\mathrm{aft}~X,~(2~1-)^2~2~\mathrm{aft}~X,\ldots\} </math>  
第209行: 第203行:
<math>psd.(2~1-)^\omega~2=A\cup1-A</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. 的联系。
定义完了 <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>。
重要: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 函数 ====
==== 多元 I 函数 ====
顺着<math>I(\omega+1,0)</math>继续往上,使用容许点进位的规则和 psd. 定义,有:
顺着 <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+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>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-)^{\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>(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>。
上标增加到一定程度,自然就会出现不动点。与 <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>
我们可以像这样用二元 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</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,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> 的强度借助不动点,有了一个提升'''。
<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 并没有新的附加规则,只需要牢记容许点进位即可。如
后面的多元 I 并没有新的附加规则,只需要牢记容许点进位即可。如
第247行: 第241行:


=== 递归马洛序数 ===
=== 递归马洛序数 ===
''前排提示:关于M在OCF中的折叠规则,参见词条[[递归马洛序数]]''
''前排提示:关于 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>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_2,M_3,\dots</math>,就像这样:<math>2-2=\{M,M_2,M_3,\dots,M_{\omega+1},\dots\}</math>


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


对递归马洛序数的集合进行 1- 反射,可以得到:
对递归马洛序数的集合进行 1- 反射,可以得到:
第259行: 第253行:
<math>1-2-2=\{M_\omega,M_{\omega\times2},\dots,M_{\omega^2},\dots,M_M,\dots\}</math>
<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> 的不动点。
即 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>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-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~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 吧。
还可以更深入地了解一下 <math>2-2~1-2-2</math> 这个大序数的性质。暂时把它记作 X 吧。


首先, X 要能折叠<math>(2~1-)</math> 操作,所以它至少要是递归马洛序数,即<math>X\in2-2</math> ;
首先, 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>。
然后,需要考虑一下这样的 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>(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点'''。
我们称这样既是递归马洛序数,又是函数 <math>f(\alpha)</math> 不动点的序数,称为该函数的 '''M 点'''。


=== 更深的反射 ===
=== 更深的反射 ===
''tips:这里的任意深度可以理解为,你有一个强度穷尽所有递归序数的扩展veblen函数,这里你的上标则拥有任意强度的你的扩展veblen。''
''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-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~1-</math> 操作的上标也可以进一步加深。自然地,有一个大序数折叠它。这就是 2-2-2 ,我们将其称为不可转换序数,记作 N。即:


<math>2-2-2=\{N,N_2,\dots,N_{\omega+1},\dots\}</math>
<math>2-2-2=\{N,N_2,\dots,N_{\omega+1},\dots\}</math>
第287行: 第281行:
<math>2-2-2~\text{折叠}~(2-2~1-)^{a,b,c,\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>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-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}</math> 的印象了。我们可以这样理解 <math>2~\mathrm{onto}</math> 集合 X 的行为:


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


可以发现,这个集合 X 越强,<math>2~\mathrm{onto}</math>所折叠的操作也越强。而反过来,如果这个 X 本身性质不够好的话,也会“连累” <math>2~\mathrm{onto}</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.定义,即
那么,通往 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>\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> 是理想状态的 <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>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> 等 ====
==== <math>(2-)^{1,0}</math> 等 ====
第312行: 第306行:
<math>\min~(2-)^{\omega\times2}=\sup\{\min~(2-)^{\omega+1},\min~(2-)^{\omega+2},\min~(2-)^{\omega+3},\dots\}</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>点”的操作。
<math>(2-)^{\omega\times2+1}=real.(2-)^{\omega\times2}</math> 折叠“取 <math>(2-)^{\omega\times2}</math> 点”的操作。


上标上的序数可以一直增加,每次经过极限序数的时候都会碰到一点关于 psd. 和 real. 的破事。不过,对于不想搭理这些破事的读者,记住 psd. 规则和“ real. 相当于 +1 ”就已经足够了。
上标上的序数可以一直增加,每次经过极限序数的时候都会碰到一点关于 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>(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>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 psd.(2-)^{1,0}\Leftrightarrow \forall\beta<\alpha,\exists\gamma\in(2-)^\beta,\gamma<\alpha</math>
第324行: 第318行:
<math>\alpha\in real.(2-)^{1,0}\Leftrightarrow\forall\beta<\alpha,\alpha\in(2-)^\beta</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> 只要求对于所有 <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>psd.(2-)^{1,0}</math> 显然不是容许序数。可以用类似 OFP 的方式为它找到一条长度为 ω 的递归基本列。


不想搭理破事的读者依旧可以把 <math>real.(2-)^{1,0}</math>理解为<math>(2-)^{1,1}</math>,它折叠“取 <math>(2-)^{1,0}</math>点”的操作。这里就不展开细说了。
不想搭理破事的读者依旧可以把 <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>之类的东西。
然后,是 <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>
折叠 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>


所有的递归弱紧致序数,都同时是容许序数、递归不可达序数、递归马洛序数、不可转换序数……等等等等。
所有的递归弱紧致序数,都同时是容许序数、递归不可达序数、递归马洛序数、不可转换序数……等等等等。
第341行: 第335行:
可以对 3 这个集合施加<math>\Pi_1</math>、 <math>\Pi_2</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>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 点。
<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 的路又走了一遍。
从 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>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>。
花吃奶的劲突破超限序数,到达 <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 就会更加强得可怕。
而 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>\Pi_3</math> 反射能形成的丰富结构中最靠前的一部分。


==== 从<math>2-3</math> 到<math>3~2-3</math>再到 <math>(3~2-)^{a,b,c,\dots}~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>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-)^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 点。
什么折叠任意深度的 <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-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-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>。
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-)^{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-)^{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~1-3~2-3</math>,这是“计数 <math>3~2-3</math> 的函数”的容许点。


<math>2-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>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-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-3~1-2-3~1-3~2-3=(2-3~1-)^2~3~2-3</math>。
第388行: 第382行:
……
……


然后,有 <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~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> 点”的概念。


再取一次 3~2-3 点看看。<math>3~1-3~2-3~1-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>。
<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- 操作,都要折叠一次“取自己点”的操作。好一个折叠再折叠。
稍微理一下这一段的逻辑:我们对一个表达式不断地进行 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~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>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>k~\mathrm{onto}~X (k\geq2)</math> 的行为:<math>k~\mathrm{onto}~X</math> 是对 <math>(X~\cap~(k-1)-)</math> 的折叠。


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


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


第一步,替换。把反射式中间的空格和 - 都替换为逗号,然后倒序排列。例如 <math>2-4~2-3-4</math> 先变为 2,4,2,3,4 ,再倒序排列为 4,3,2,4,2 ;
第一步,替换。把反射式中间的空格和 - 都替换为逗号,然后倒序排列。例如 <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>;
第二步,补项。若第一项为 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>;


第三步,展开。按照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>\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>。


于是我们得到:<math>2-4~2-3-4</math>折叠任意深度的<math>(4~2-3-4~1-)^{a,b,c,\dots}4~2-3-4</math>。
{{默认排序:非递归记号}}
[[分类:记号]]
[[分类:记号]]

2025年8月26日 (二) 16:25的最新版本

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

数学定义

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

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

满足如下条件之一的集合论公式称为 Δ0 公式:

  1. 它不包含无界量词
  2. 它形如 φψ,φψ,¬φ,φψ,φψ,其中 φ,ψΔ0 公式
  3. 它形如 (xy)φ(xy)φ,其中 φΔ0 公式

Δ0 公式中的所有量词都是有界的。

Σn 公式及 Πn 公式定义如下:

  1. Σ0 公式及 Π0 公式为 Δ0 公式。
  2. 如果 φΠn 公式,则 x1xmφΣn+1 公式。
  3. 如果 φΣn 公式,则 x1xmφΠn+1 公式。

反射的定义:

L 为可构造宇宙Lα 在 X 上反射了公式 φ,是说 Lαφβ(Xα)Lβφ。若 Lα 在 X 上反射了所有的 Πn(Σn) 公式,则称 α 是 X 上的 Πn(Σn) 序数。特别的,若 Lα 在所有序数上反射了所有的 Πn(Σn) 公式,则称 α 是 Πn(Σn) 序数。

或者说,一个序数 β 被称为 X 上的 Γ反射序数,当且仅当 ψΓ(Lβψγ(Xβ)(Lγψ))

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

  • α 是 X 上的 Πn 反射序数,等价于 α 是 X 上的 Σn+1 反射序数(也就是说,我们只需要研究集合上的 Πn 反射序数即可)
  • α 是 X 上的 Π0 反射序数,等价于 α 是 X 上的 Π1 反射序数,等价于 α 是 X 上的极限点
  • α 是 X 上的 Π2 反射序数,等价于 α 是 X 上的容许序数

注:在一些资料中,会出现 Π0 反射等价于全体序数的说法。这是错误的。事实上,如果我们想要写出全体序数,应该写出 𝐎𝐫𝐝(或 𝐎𝐧

结构讲解

基本符号

onto

onto 是反射模式的核心。它的作用对象是一个集合,同时也输出一个集合。例如: Π1 onto 𝐎𝐫𝐝,得到的是全体极限序数构成的集合;Π2 onto 𝐎𝐫𝐝构成的集合,得到的是全体容许序数构成的集合。

方便起见,我们把 Πn onto X 简写为 n-X 。这里的 n 是自然数, X 是被操作的集合。特殊地,当 X 为全体序数,我们直接将它省略不写,此时的结果直接记为 n 。也就是说,在反射模式中, 1 可以用来表示 Π1 onto 𝐎𝐫𝐝 的结果,以此类推。

即:Γref. onto X 定义为所有 X 上的 Γ-反射序数的集合。

这里的 ∩ 指交集。没错,就是那个大家熟知的交集, AB 表示同时属于集合 A 和集合 B 的元素。交集也是反射模式中的一种重要运算。同样是为了方便起见,我们将 ∩ 简写为空格。 ∩ 在反射式中的运算优先级与 onto 相同,并且从右向左计算。例如: 2 1-2 表示Π2(Π1 onto Π2) 的集合; 2-3 1-3 2-3 表示 Π2 onto (Π3(Π1 onto (Π3(Π2 onto Π3)))) 的集合。

min,2nd,3rd 以及 nth

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

aft

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

Π1 反射

1- 的作用

Π1 onto 一个集合的效果,是取出这个集合中所有的极限点。所谓的极限点,就是前极限序数个元素的上确界。

现在我们可以来推导一下 1 ,也即 Π1 onto 全体序数的构成。

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

前 ω 个序数的上确界为 ω,前 ω×2 个序数的上确界为 ω×2……

事实上, 1 就等于全体极限序数的集合 {ω,ω×2,,ω2,,ωω,Ω,}

类似地, 1 中的前 ω 个序数的上确界是 sup{ω,ω×2,ω×3,}=ω2,1 中的前 ω×2 个序数的上确界是 sup{ω,ω×2,,ω2,ω2+ω,}=ω2×2……因此,11={ω2,ω2×2,,ω3,,ωω,,Ω,},是 ω2 的倍数的集合。

继续递推,还能得到

111={ω3,ω3×2,,ωω,,Ω,}

1111={ω4,ω4×2,,ωω,,Ω,}

……直到:

(1)ω

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

但,(1)ω呢?

我们首先需要定义 (1)ω。较一般地,对于 (1)α ,其中 α 为极限序数的情况,我们只需要取交集,即定义 (1)α=β<α(1)β

自然地,我们可以推导出 (1)ω={ωω,ωω×2,,ωω+1,,Ω,},即 ωω 的倍数的集合。

(1)α,就是 ωα 的倍数的集合,min (1)α=ωα

(1)1,0

上标只能放序数的情形是简单的,一个“ωα 的倍数”就直接解决了。如何让情形变得更有趣呢?我们可以借用 Veblen 函数的不动点进位模式,在上标上引入多个数字,来表示不同层级的不动点。

我们定义 (1)1,0={α|α=min (1)α}。根据上一节的结论,我们可以知道 min (1)α=ωα。因此,(1)1,0是全体 ε 序数的集合,即 {ε0,ε1,,εω,,ζ0,,Ω,}

可以继续对 (1)1,0 进行 1- 的操作,得到的集合记为 (1)1,1(1)1,1 应当是全体“下标为极限序数的 ε 序数”的集合,即(1)1,1={εω,εω×2,,εω2,,ζ0,,Ω,}

更一般地,我们在上标上使用 weak Veblen 函数,记 1(1)#,α(1)#,α+1。于是,我们还可以有 (1)1,2,(1)1,ω,(1)1,ε0,。在上标遇到极限序数时,我们也仍取交集。

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

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

Π2 反射和容许序数

Π2onto 任意集合的作用,暂时是难以说明的,所以我们先从 Π2 onto 𝐎𝐫𝐝 开始。这里不加证明地给出以下结论:Π2 反射作用于全体序数的集合,得到的是全体容许序数的集合。

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

最小的容许序数是 Church-Kleene 序数,记为 ω1CK,在这里我们把它写作 Ω——没错,就是在 OCF 中出现的那个。

紧接着,第二个容许序数是 ω2CK,在这里写作 Ω2。它无法通过包括 Ω 在内的比它小的序数通过递归运算得到,这意味着 Ω2 不是 Ω×2,Ω2,εΩ+1,φ(Ω,1) 之类的东西,而是远远在它们之上的存在。

再然后,还会有 Ω3,Ω4,,Ωω+1,,ΩΩ+1, 它们一同组成了容许序数的集合。

值得注意的是,上面一句话跳过了 Ωω,ΩΩ,而单独列出了 Ωω+1ΩΩ+1。这是因为 ΩωΩΩ 并非容许序数——这一点可以通过“找长度小于它本身的基本列”来实现。

更进一步地,OFP=ψI(0) 存在一条长度为 ω 的基本列 {Ω,ΩΩ,ΩΩΩ,},它也是非容许的。

事实上,对于大多数的 Ωα,其中 α 为极限序数, α 的基本列总是会成为我们我们的突破口,让我们找到 Ωα 的一条长度小于自身的基本列。

顺便一提,对于所有的后继序数 α,Ωα 都毫无疑问是容许序数。

12,(1)1,02

1-2 ,即取出集合 2={Ω,Ω2,,Ωω+1,,ΩΩ+1,} 中所有的极限点。

2 中的前 ω 个序数的上确界是 sup{Ω,Ω2,}=Ωω,所以 Ωω12

2 中的前 ω×2 个序数的上确界是 Ωω×2,所以 Ωω×212……

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

接着是 1-1-2 。我们取集合 1-2 的极限点,可以得到“Ωα,其中 α 为 ω2 的倍数”的集合。同样地,我们可以通过取交集得到 (1)ω2,(1)ω22 乃至 (1)Ω2。由于 Ω=min2,所以 (1)Ω2 又可以写作 (1)(2)2 。这里在上标上省略了 min ,并且在外面加了一层括号用以和序数 2 区分。

于是我们来到了 (1)1,02。类似 (1)1,0 的定义,(1)1,02={α|α=(1)α2}。不难发现,(1)1,02 的每一个元素 α 都满足 α=Ωα,因此,(1)1,02 是全体 OFP 的集合。{ψI(0),ψI(1),,ψI(Ω),,ψI(I),}.

(1)1,02 过后,同样也有 (1)2,02,(1)1,0,02,。不过,不管 (1)a,b,c,2 的上标的层级多深,只要它还是不动点的形式,它就是非容许的。

递归不可达序数

前排提示:关于 I 及多元 I 函数在 OCF 中的折叠规则,参见词条递归不可达序数

我们不妨思考一下,若一个极限序数 α 足以使得 Ωα 为容许序数的话,它需要满足什么条件呢?

首先,α 是容许序数;其次, α12 。即满足上述条件的 α 属于 2 和 1-2 的交集,记为 α212

根据 ZFC 公理体系,我们可以直接证明 2 和 1-2 的交集存在元素,我们将其命名为递归不可达序数。最小的递归不可达序数记作 I ,次小的是I2……就和 Ω,Ω2差不多。

总之,212={I,I2,,Iω+1,,II+1,,I(1,0),}。注意到这里也没有列出 IωIω 并非容许序数。

接下来,我们还可以对 2~1-2 进行若干次 1-,例如 1212={Iω,Iω×2,,II,,IFP,}。推导过程和 1-2 是一致的,注意 1-2~1-2 表示的实际上是 1onto(212)

(1)1,0212 自然是全体 IFP,也就是满足 α=Iα的序数构成的集合。

容许点

对“容许点”的定义,即:

序数 Θ 为函数 f(α) 的容许点,等同于 Θf(α) 的不动点且为容许序数。

于是我们可以看到,Ω 是函数 f(α)=ωα 的容许点;I 是函数 f(α)=Ωα 的容许点。

更一般地,若函数 f(α) 的值域是集合 A ,那么 f(α) 的容许点组成的集合是 21A

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

I(1,0) 等二元 I 函数

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

根据前面提到的“若函数 f(α) 的值域是集合 A ,那么 f(α) 的容许点组成的集合是 21A 。”的规则,不难知道,函数 f(α)=Iα 的全体容许点的集合是 21212

f(α)=Iα 的次小的容许点是 I(1,1) 。这里,二元 I 的最后一位实质上相当于 Ω 或者 I 的下标。于是,(21)22=21212={I(1,0),I(1,1),,I(1,ω+1),}I(1,ω) 同样是非容许的。

(1)1,021212 是函数 f(α)=I(1,α)的不动点,记作 I(1,a)FP 。最小的 I(1,a)FP也并非 I(2,0) 。 I(2,0) 是函数 f(α)=I(1,α) 的容许点。多元 I 函数的这种进位方式,称为容许点进位

……

像这样继续往前,自然会遇到 (21)ω2,我们期望它是 {I(ω,0),I(ω,1),}。如果我们仍用定义 (1)ω 时的交集来定义它会怎么样呢?下面才会真正开始涉及真伪的争端……

psd. 和 real.

I(ω,α) 的定义方式与 φ(ω,α) 是类似的。即:

I(ω,0)=sup{I(n,0)|n}

I(ω,α)=sup{I(n,I(ω,α1)+1)|n}(α为后继序数)

I(ω,α)=sup{I(ω,β)|β<α}(α为极限序数)

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

对于 I(ω×2,α),I(ω2,α) 等“高位为极限序数的二元 I 函数”的情形,都可以像这样定义。对于绝大多数极限序数 β 和后继序数 α,I(β,α) 都不是容许序数。

real.(2 1)ω 2

对于使用交集定义的 (21)ω2,一般称作 real.(21)ω2。即 real.(21)ω2=n<ω(21)n2

现在让我们思考一下一个序数如果要是 real.(21)ω2,它需要具备哪些性质。根据上面的结论,我们可以推出:

αreal.(21)ω2α 为容许序数 αf,g,h1, 等函数的不动点

首先关注后面的条件。利用类似 Veblen 函数的“闭包”机制,可以证明,α 为这些函数的不动点等同于 α=I(ω,β)。那么,整个条件就变为了“α 是 I(ω,) 序数且 α 为容许序数”。这正是我们要刻画的 real.(21)ω2 的模样。

real.(21)ω2

像这样直接跳过 I(ω,α) 一族序数似乎不太好。我们希望能有一个简单的反射式子来表示它们,并且最好这个简单的式子就是 (21)ω2。这就引出了下面的 psd.(21)ω2 的定义:

AaftX=sup{2aftX,212aftX,(21)22aftX,}

psd.(21)ω2=A1A

定义完了 psd.(21)ω2 之后,我们会发现 real.(21)ω2 实际上就是 21psd.(21)ω2=psd.(21)ω+12。如此一来就建立了 psd. 和 real. 的联系。

重要:psd. 和 real. 的形式类似、性质则相当不同,容易引起不必要的争端。因此,本条目在之后提及 (21)ω2 和类似的 (221)ω22,(2)ω 等序数时,若不使用前缀,则默认为 psd. 定义。因此,可以直接写 real.(21)ω2=21(21)ω2=(21)ω+12

多元 I 函数

顺着 I(ω+1,0) 继续往上,使用容许点进位的规则和 psd. 定义,有:

I(ω+2,0)f(α)=I(ω+1,α) 的最小的容许点, (21)ω+22={I(ω+2,0),I(ω+2,1),,I(ω+2,ω+1),}

I(ω+3,0)f(α)=I(ω+2,α) 的最小的容许点,(21)ω+32={I(ω+3,0),I(ω+3,1),,I(ω+3,ω+1),}

(21)ω×22 是全体 I(ω×2,) 序数。 real.(21)ω×22=(21)ω×2+12

……

像这样,我们可以确定任意的 (21)α2(α>ω)的景象。当 α 为后继序数时,(21)α2 是全体I(α,) 序数中的容许序数;当 α 为极限序数时,(21)α 就是全体 I(α,) 序数。

上标增加到一定程度,自然就会出现不动点。与 (1)1,0 类似地,我们把满足 α=min(21)α2 的序数集合记作 (21)1,02

我们可以像这样用二元 I 函数来表示它 :(21)1,02={α|α=I(α,0)}

(21)1,02 是全体 αI(α,0) 的不动点。最小的这样的不动点该如何用多元 I 表示? I(1,0,0) 吗?不要忘了 I 的容许点进位规则。它应该是 ψI(1,0,0)(0) 。次大的不动点自然就是ψI(1,0,0)(1)了。所以,有:

(21)1,02={ψI(1,0,0)(0),ψI(1,0,0)(1),,ψI(1,0,0)(ω),,I(1,0,0),}

(21)1,12=21(21)1,02 是函数 f(α)=ψI(1,0,0)(α) 的容许点,也就是全体 I(1,0,)序数中的容许序数。在这里,21 的强度借助不动点,有了一个提升

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

(21)1,22={I(1,1,0),I(1,1,1),,I(1,1,ω+1),,I(1,2,0),}

(21)2,12={I(2,0,0),I(2,0,1),,I(2,0,ω+1),,I(2,1,0),}

(21)1,0,0,12={I(1,0,0,0,0),I(1,0,0,0,1),,I(1,0,0,0,ω+1),,I(1,0,0,1,0),}

……

递归马洛序数

前排提示:关于 M 在 OCF 中的折叠规则,参见词条递归 Mahlo 序数

进一步增加 21 的上标的深度之后,我们会被一道新的不可逾越之壁所阻挡。正如同 Ω=min2 无法通过单纯的 1- 操作得到一样, M=min22 也无法通过单纯的 21 操作得到。我们把这样的 M 称作递归马洛序数。

递归马洛序数有无穷多个。我们把第二个,第三个……递归马洛序数分别记为 M2,M3,,就像这样:22={M,M2,M3,,Mω+1,}

当然了,Mω 也不是递归马洛序数。它甚至不是容许序数——所有的递归马洛序数都是容许序数。

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

122={Mω,Mω×2,,Mω2,,MM,}

即 1-2-2 是全体 “Mα,其中 α 为极限序数”所构成的集合。自然地,我们有 (1)1,022。根据定义,它是全体满足 α=min(1)α22 的集合,也就是 MFP ,函数 f(α)=Mα 的不动点。

那么,函数 f(α)=Mα 的容许点又如何呢?根据前文所讲的容许点的性质,可以知道,这个函数的全体容许点构成了集合 2122。后面 (21)a,b,c,22类似前文所述的多元 I 函数,这里不再赘述。

22122

接下来,会有一个序数能折叠 (21)a,b,c,22。也就是,任意深度的 (21) 操作到 2-2 这个集合上,都得不到它。这个序数就是 22122 ,即 2onto2122

还可以更深入地了解一下 22122 这个大序数的性质。暂时把它记作 X 吧。

首先, X 要能折叠 (21) 操作,所以它至少要是递归马洛序数,即 X22

然后,需要考虑一下这样的 X 相对于普通的递归马洛序数有哪些不同之处。 X 能折叠出函数 f(α)=Mα 的容许点,而这些容许点有什么特性呢?回到容许点的定义,可以知道,这些容许点都是 f(α)=Mα 的不动点,也即 MFP=(1)1,022

所有的 (1)1,022 自然也是 1-2-2 。那么,就得到了 22122 同时是 2-2 和 1-2-2 的结论。更进一步的证明显示,2212222122 等价——这可不是一句无意义的废话。我们对 22122 的定义实际上是 2(2122),这里证明了交集和最左侧的 onto 运算次序可以交换。

我们称这样既是递归马洛序数,又是函数 f(α) 不动点的序数,称为该函数的 M 点

更深的反射

tips:这里的任意深度可以理解为,你有一个强度穷尽所有递归序数的扩展 Veblen 函数,这里你的上标则拥有任意强度的你的扩展 Veblen。

可以对 22122 继续进行 1- 和 21 操作,得到更大的序数。同样地,我们会有 (21)1,0,0122122(21)1,0,0,0122122,以及折叠它们的 2212212222122122 也等同于 22122122。我们可以对其不断进行 221 操作。

221 操作的上标也可以进一步加深。自然地,有一个大序数折叠它。这就是 2-2-2 ,我们将其称为不可转换序数,记作 N。即:

222={N,N2,,Nω+1,}

222折叠(221)a,b,c,

类似的,2221222 是函数 f(α)=Nα的N点。

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

到这里,足以勾勒出一个对 2onto 的印象了。我们可以这样理解 2onto 集合 X 的行为:

2ontoX 是对 (X1) 的折叠。

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

那么,通往 2-2-2-2-2 的路也明确了。类似地,还能继续得到 (2)6,(2)7,,直至 (2)ω。这里的 (2)ω 也使用 psd. 定义,即

min(2)ω=sup{2,22,222,}

real.(2)ω 是理想状态的 (2)ω+1。思路和 real.(21)ω2=psd.(21)ω+12 是类似的。

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

(2)1,0

现在,可以对它们进行 2- 反射以继续前进了。也就是:

(2)ω+2 折叠任意深度的 ((2)ω+11)a,b,c,(2)ω+1

min(2)ω×2=sup{min(2)ω+1,min(2)ω+2,min(2)ω+3,}

(2)ω×2+1=real.(2)ω×2 折叠“取 (2)ω×2 点”的操作。

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

接下来,还会有 (2)Ω=(2)(2)(2)M=(2)(22),以及 (2)(2)ω(2)(2)(2)ω……这样做的极限就是 (2)1,0了。

注意到上一句话的用词是“极限”而不是“不动点”。这样用词是因为这里也有 psd.vs.real. 的定义问题。对于 (2)1,0,有如下定义:

αpsd.(2)1,0β<α,γ(2)β,γ<α

αreal.(2)1,0β<α,α(2)β

简而言之,psd.(2)1,0 只要求对于所有 β<α ,在 α 的下方都存在一个 (2)β 的序数,对 α 自身的性质未作出要求;而 real.(2)1,0 要求 α 自身就是 (2)β 序数。

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

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

然后,是 2(2)1,1=(2)1,2,(2)1,ω,(2)1,Ω, 以及这样做的极限 (2)2,0。上标的规则没什么变化。进一步加深上标,就会得到 (2)1,0,0 之类的东西。

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

递归弱紧致序数

折叠 2- 操作的序数称为递归弱紧致序数,写作 K 。全体递归弱紧致序数构成的集合也是 Π3 反射作用于全体序数得到的集合,在反射模式中记作 3 。即 3折叠(2)a,b,c,={K,K2,K3,,Kω+1,}

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

可以对 3 这个集合施加Π1Π2反射操作,继续枚举:

13={Kω,Kω×2,,KΩ,,KK,}(1)1,03 是所谓的 KFP 构成的集合。213 是函数 f(α)=Kα 的容许点。2213 折叠任意深度的 (21)a,b,c,3,它们也是函数f(α)=Kα 的马洛点。22213 折叠任意深度的(221)a,b,c,3,它们也是函数 f(α)=Kα 的 N 点。(2)1,013 是满足“对于任意 β<α,都存在 γ(2)β13 使得 γ<α”的全体序数 α 构成的集合,它也是集合 (2)1,0 与集合 1-3 的交集。

313 是集合 3 与集合 1-3 的交集,折叠任意深度的 (2)a,b,c,13。与 212 类似,它也可以被理解为全体“足以使得 Kα 是递归弱紧致序数的极限序数 α”所构成的集合,以及函数 f(α)=Kα 的 K 点。

从 3 到 313 ,我们相当于把从 Ord 到 3 的路又走了一遍。

再走第二遍的话,我们就会路过 21313,221313,(2)1,01313,,最终到达 31313=(31)23。再走第三遍,到达 (31)33

花吃奶的劲突破超限序数,到达 (31)1,03

而 2-3 可以折叠任意深度的 (31)a,b,c,3。正如我们上一篇所说的, 2-X 折叠 (X1) 的操作。 X 本身强得可怕的时候, 2-X 就会更加强得可怕。

以上,还只是 Π3 反射能形成的丰富结构中最靠前的一部分。

23323 再到 (32)a,b,c,3

继续构造一个函数 f(α) 用来表示“第 α 个 2-3 ”,然后继续前进。中间又会经过 2123,22123,(2)1,0123,而 3123 是这个函数的 K 点。

然后,是 (31)223,(31)ω23,(31)1,023 之类的东西。

什么折叠任意深度的 (31)a,b,c,23 呢?注意到从 2-3 到这里的过程相当于从 Ord 到 2-3 ,所以它应该是 23123,也就是 f(α) 的 2-3 点。

利用“取 2-3 点”的操作,又可以有 23123123=(231)223,(231)ω23,(231)1,023 等等。

在这之后, 2-2-3 能折叠任意深度的 (231)a,b,c,23,也就是“取 2-3 点”这么一个操作。

2-2-2-3 折叠任意深度的 (2231)a,b,c,223。这一部分和前面的 2-2-2 没什么不同,只是底层由“ 1- 反射”变为了“31 操作”。直到 (2)ω3

(2)1,03。在它下面的每一个 β ,都存在一个 (2)β3 序数小于它。

接下来考虑一个能折叠任意深度的 (2)a,b,c,3 的序数。这个序数能折叠 2- 的操作,所以是一个 Π3 序数;同时,它又至少是 2-3。因此,这个序数至少是 3 和 2-3 的交集。依旧可以证明,这个条件已经足够了。也就是 323折叠(2)a,b,c,3

21323,这是“计数 323 的函数”的容许点。

221323,这是“计数323 的函数”的马洛点。

31323,这是“计数 323 的函数”的 K 点。

……

231323 折叠任意深度的 (31)a,b,c,23。这里是一个易错点。根据前面提到的“2-3 折叠(31)a,b,c,”可以知道。折叠 (31)a,b,c,23 的应该是“计数 323 的函数”的 2-3 点,也就是 231323,而并非 2323

231231323=(231)2323

2231323 折叠任意深度的 (231)a,b,c,323

……

然后,有 3231323 折叠任意深度的 (2)a,b,c,31323。它是“计数 323 的函数”的 323 点。这是我们第一次在“XX 点”的概念中涉及到交集。2323 要折叠的正是这个“取 323 点”的概念。

再取一次 323 点看看。313231323

2313231323 折叠任意深度的 (31)a,b,c,323132322313231323 折叠任意深度的 (231)a,b,c,323132332313231323=(3231)2323 折叠任意深度的 (2)a,b,c,313231323。再才有 2323 折叠任意深度的 (3231)a,b,c,323232312323 是“计数 2323 的函数”的 2323 点。22323 折叠任意深度的 (23231)a,b,c,232332323 折叠任意深度的 (2)a,b,c,323232323 折叠任意深度的 (323231)a,b,c,32323

稍微理一下这一段的逻辑:我们对一个表达式不断地进行 2- 的操作,折叠 2- 操作的是最前面有个“3 ”(注意空格)的表达式;然后对这个有“3 ”的表达式再不断进行 2- 操作,再折叠它……最终形成一条 3232323 的链条。每一次最基础的 2- 操作,都要折叠一次“取自己点”的操作。好一个折叠再折叠。

延伸这个链条到超限序数,就能看到 (32)ω3还有(32)1,03

现在,终于可以打开 3onto 的大门了。3onto 集合 X 的行为实际上与 2ontoX 很像。我们有 3ontoX是对 (X2) 的折叠。

更进一步地,我们可以给出 kontoX(k2) 的行为:kontoX 是对 (X(k1)) 的折叠。

理论上,现在我们畅通无阻、直通 Πω 了。

反射式的展开操作规则

是否存在一套简单的规律以便我们判断某一个反射式折叠了什么操作?答案是肯定的。并且这一规律奇妙地与 PrSS 存在联系。具体操作分为以下几步:

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

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

第三步,展开。按照 PrSS 规则展开序列,复制坏部的时候需要连标记一并复制,但坏根除外。上一步的结果在这里展开为 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),

最后一步,还原。去掉被标记的项,倒序回来,将逗号还原为空格和 -,此时的结果就是原来的反射式要折叠的结构。上一步的展开结果还原为 (42341)(42341)(42341)4234,即 (42341)a,b,c,4234

于是我们得到:24234 折叠任意深度的 (42341)a,b,c,4234