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

序数坍缩函数:修订间差异

来自Googology Wiki
Phyrion留言 | 贡献
无编辑摘要
Tabelog留言 | 贡献
无编辑摘要
第1行: 第1行:
'''序数塌缩函数(Ordinal Collapsing Function,OCF)'''是一种[[序数]]函数。它们的特点是利用足够大的序数(通常是[[序数#非递归序数|非递归序数]])来输出递归序数。事实上,OCF有很多不同的版本。本词条着力于介绍[[EBO]]之前的'''BOCF'''(Buchholz's OCF)和'''MOCF'''(Madore's OCF)。
'''序数塌缩函数(Ordinal Collapsing Function,OCF)'''是一种[[序数]]函数。它们的特点是利用足够大的序数(通常是[[序数#非递归序数|非递归序数]])来输出递归序数。事实上,OCF 有很多不同的版本。本词条着力于介绍 [[EBO]] 之前的 '''BOCF'''(Buchholz's OCF)和 '''MOCF'''(Madore's OCF)。


== BOCF ==
== 教学 ==
 
=== BOCF 简介 ===
''前排提醒:对严谨数学定义不感冒或看不懂的读者可以直接跳到[[OCF#直观理解与操作规则|直观理解与操作规则]]。''
''前排提醒:对严谨数学定义不感冒或看不懂的读者可以直接跳到[[OCF#直观理解与操作规则|直观理解与操作规则]]。''


=== 定义 ===
==== 定义 ====
首先我们给出BOCF只引入第一个非递归序数<math>\Omega</math>的定义:
首先我们给出 BOCF 只引入第一个非递归序数 <math>\Omega</math> 的定义:


# <math>C_0(x)=\{0,\Omega\}</math>
# <math>C_0(x)=\{0,\Omega\}</math>
第12行: 第14行:
# <math>\psi(x)=min\{\alpha<\Omega|\alpha\not\in C(x)\}</math>
# <math>\psi(x)=min\{\alpha<\Omega|\alpha\not\in C(x)\}</math>


其中的<math>\Omega</math>要求是一个足够大的序数。以往的资料一般使用第一个[[序数#可数序数与不可数序数|不可数序数]]<math>\omega_1</math>来作为它。但我们发现,第一个非递归序数<math>\omega_1^{CK}</math>已经可以满足我们的需求。因此,目前提到<math>\Omega</math>,默认指的是<math>\omega_1^{CK}</math>。
其中的 <math>\Omega</math> 要求是一个足够大的序数。以往的资料一般使用第一个[[序数#可数序数与不可数序数|不可数序数]] <math>\omega_1</math> 来作为它。但我们发现,第一个非递归序数 <math>\omega_1^{CK}</math> 已经可以满足我们的需求。因此,目前提到 <math>\Omega</math>,默认指的是 <math>\omega_1^{CK}</math>。


这四条规则很是抽象,让我们一条一条来看。
这四条规则很是抽象,让我们一条一条来看。


规则1:<math>C_0(x)=\{0,\Omega\}</math>。对于任意的x , <math>C_0(x)</math>是同一个集合。
规则 1:<math>C_0(x)=\{0,\Omega\}</math>。对于任意的 x , <math>C_0(x)</math> 是同一个集合。


规则2,这个规则递归定义了<math>C_{n+1}(x)</math>,它是<math>C_n(x)</math>再加上<math>C_n(x)</math>中的元素通过加法和ψ函数能产生的所有元素。这里要求ψ函数自变量小于x,因为<math>\psi(x)</math>是需要<math>C(x)</math>来定义的。
规则 2,这个规则递归定义了 <math>C_{n+1}(x)</math>,它是 <math>C_n(x)</math> 再加上 <math>C_n(x)</math> 中的元素通过加法和 ψ 函数能产生的所有元素。这里要求 ψ 函数自变量小于 x,因为 <math>\psi(x)</math> 是需要 <math>C(x)</math> 来定义的。


规则3,<math>C(x)</math>是对所有的<math>C_n(x)</math>取并集得到的集合。
规则3,<math>C(x)</math> 是对所有的 <math>C_n(x)</math> 取并集得到的集合。


规则4,<math>\psi(x)</math>就是所有小于<math>\Omega</math>的序数中,不属于<math>C(x)</math>的最小序数。
规则4,<math>\psi(x)</math> 就是所有小于 <math>\Omega</math> 的序数中,不属于 <math>C(x)</math> 的最小序数。


=== <math>\varepsilon_0</math>之前 ===
==== <math>\varepsilon_0</math> 之前 ====
以下是一些运算实例:
以下是一些运算实例:


<math>C_0(0)=\{0,\Omega\}</math>
* <math>C_0(0)=\{0,\Omega\}</math>
 
* <math>C_1(0)=\{0,\Omega,\Omega\times2\}</math>
<math>C_1(0)=\{0,\Omega,\Omega\times2\}</math>
* <math>C_2(0)=\{0,\Omega,\Omega\times2,\Omega\times3,\Omega\times4\}</math>
 
*……
<math>C_2(0)=\{0,\Omega,\Omega\times2,\Omega\times3,\Omega\times4\}</math>
 
……


<math>C(0)=\{0,\Omega,\cdots\}</math>,省略号省掉了大于<math>\Omega</math>的序数
<math>C(0)=\{0,\Omega,\cdots\}</math>,省略号省掉了大于 <math>\Omega</math> 的序数。


因此<math>\psi(0)</math>是最小的小于<math>\Omega</math>的不在<math>C(0)</math>里的序数,即1.
因此 <math>\psi(0)</math> 是最小的小于 <math>\Omega</math> 的不在 <math>C(0)</math> 里的序数,即 1。


下一个例子是<math>\psi(2)</math>.假定首先你已经知道了<math>\psi(1)=\omega</math>(可以自己验证),我们要开始计算<math>\psi(2)</math>,还是不展示大于<math>\Omega</math>的序数
下一个例子是 <math>\psi(2)</math>,假定首先你已经知道了 <math>\psi(1)=\omega</math>(可以自己验证),我们要开始计算 <math>\psi(2)</math>,还是不展示大于 <math>\Omega</math> 的序数:


<math>C_0(2)=\{0,\Omega\}</math>
* <math>C_0(2)=\{0,\Omega\}</math>
* <math>C_1(2)=\{0,\psi(0)=1,\Omega,\cdots\}</math>
* <math>C_2(2)</math> 包含了 1,2 和 <math>\psi(1)</math>,即 ω
* <math>C_3(2)</math> 包含了 <math>1,2,3,4,\omega,\omega+1,\omega+2,\omega\times2</math>


<math>C_1(2)=\{0,\psi(0)=1,\Omega,\cdots\}</math>
以此类推,最后能得到 <math>C(2)</math> 中包含了全体小于 <math>\omega^2</math> 的序数和一大堆大于 <math>\Omega</math> 的序数。因此根据定义,<math>\psi(2)=\omega^2</math>


<math>C_2(2)</math>包含了1,2和<math>\psi(1)</math>,即ω。
ψ 函数内是极限序数并不影响定义和计算。


<math>C_3(2)</math>包含了<math>1,2,3,4,\omega,\omega+1,\omega+2,\omega\times2</math>
你有没有觉得一步一步按定义走太过于繁琐?下面给出它的 2 个性质:


以此类推,最后能得到<math>C(2)</math>中包含了全体小于<math>\omega^2</math>的序数和一大堆大于<math>\Omega</math>的序数。因此根据定义,<math>\psi(2)=\omega^2</math>
# <math>\psi(m+1)=\psi(m)\times\omega</math>,m 是任意序数
 
# <math>\psi(\lambda)=sup\{\psi(\kappa)|\kappa<\lambda\}</math>,α 是任意非 0 极限序数
ψ函数内是极限序数并不影响定义和计算。
 
你有没有觉得一步一步按定义走太过于繁琐?下面给出它的2个性质:
 
# <math>\psi(m+1)=\psi(m)\times\omega</math>,m是任意序数
# <math>\psi(\lambda)=sup\{\psi(\kappa)|\kappa<\lambda\}</math>,α是任意非0极限序数


根据这个性质,我们可以轻松的得到:
根据这个性质,我们可以轻松的得到:


<math>\psi(\omega)=\omega^{\omega}=\psi(\psi(1))</math>
* <math>\psi(\omega)=\omega^{\omega}=\psi(\psi(1))</math>
 
* <math>\psi(\omega+1)=\omega^{\omega+1}=\psi(\psi(1)+1)</math>
<math>\psi(\omega+1)=\omega^{\omega+1}=\psi(\psi(1)+1)</math>
* <math>\psi(\omega\times2)=\omega^{\omega\times2}=\psi(\psi(1)\times2)</math>
 
* <math>\psi(\omega^2)=\omega^{\omega^2}=\psi(\psi(2))</math>
<math>\psi(\omega\times2)=\omega^{\omega\times2}=\psi(\psi(1)\times2)</math>
* <math>\psi(\omega^{\omega})=\omega^{\omega^{\omega}}=\psi(\psi(\psi(1)))</math>
 
* <math>\psi(\omega^{\omega^{\omega}})=\omega^{\omega^{\omega^{\omega}}}=\psi(\psi(\psi(\psi(1))))</math>
<math>\psi(\omega^2)=\omega^{\omega^2}=\psi(\psi(2))</math>
* ……
 
<math>\psi(\omega^{\omega})=\omega^{\omega^{\omega}}=\psi(\psi(\psi(1)))</math>
 
<math>\psi(\omega^{\omega^{\omega}})=\omega^{\omega^{\omega^{\omega}}}=\psi(\psi(\psi(\psi(1))))</math>


……
到这里和[[康托范式]],[[veblen函数|Veblen 函数]]的 <math>\varphi(x)</math> 都是一致的。然而,在 <math>\varepsilon_0</math> 开始,OCF 将与它们分道扬镳。


到这里和[[康托范式]],[[veblen函数]]的<math>\varphi(x)</math>都是一致的。然而,在<math>\varepsilon_0</math>开始,OCF将与它们分道扬镳。
==== <math>\varepsilon_0</math> 与平台期 ====
<math>\varepsilon_0=\alpha\rightarrow\psi(\alpha)</math> 的第一个不动点,这里没有问题。问题出在 <math>\psi(\varepsilon_0+1)</math> 上。


=== <math>\varepsilon_0</math>与平台期 ===
注意到 <math>C_0(\varepsilon_0+1)=\{0,\Omega\}</math><math>C_1(\varepsilon_0+1)</math> 中小于 <math>\Omega</math> 的最大元素是 <math>\psi(0)</math>,<math>C_2(\varepsilon_0+1)</math> 中小于 <math>\Omega</math> 的最大元素是 <math>\psi(\psi(0))</math>,<math>C_2(\varepsilon_0+1)</math> 中小于 <math>\Omega</math> 的最大元素是 <math>\psi(\psi(\psi(0)))</math>……
<math>\varepsilon_0=\alpha\rightarrow\psi(\alpha)</math>的第一个不动点,这里没有问题。问题出在<math>\psi(\varepsilon_0+1)</math>上。


注意到<math>C_0(\varepsilon_0+1)=\{0,\Omega\}</math>,<math>C_1(\varepsilon_0+1)</math>中小于<math>\Omega</math>的最大元素是<math>\psi(0)</math>,<math>C_2(\varepsilon_0+1)</math>中小于<math>\Omega</math>的最大元素是<math>\psi(\psi(0))</math>,<math>C_2(\varepsilon_0+1)</math>中小于<math>\Omega</math>的最大元素是<math>\psi(\psi(\psi(0)))</math>……
因此,<math>\psi(\varepsilon_0)</math> 始终无法出现在这里面。这直接导致了 <math>C(\varepsilon_0+1)</math> 中,小于 <math>\Omega</math> 的最小的不在里面的依然是 <math>\psi(\varepsilon_0)</math>,相当于“卡住了”。这意味着对于所有的 <math>\varepsilon_0\leq\alpha\leq\Omega</math>,都有 <math>\psi(\alpha)=\psi(\varepsilon_0)</math>。这就像一个巨大的平台,因此称为'''平台期'''。


因此,<math>\psi(\varepsilon_0)</math>始终无法出现在这里面。这直接导致了<math>C(\varepsilon_0+1)</math>中,小于<math>\Omega</math>的最小的不在里面的依然是<math>\psi(\varepsilon_0)</math>。相当于“卡住了”。这意味着对于所有的<math>\varepsilon_0\leq\alpha\leq\Omega</math>,都有<math>\psi(\alpha)=\psi(\varepsilon_0)</math>.这就像一个巨大的平台,因此称为'''平台期'''。
直到 <math>\psi(\Omega+1)</math> 才迎来了转机。因为 <math>\Omega</math> 也在 <math>C_0(x)</math> 里面,因此 <math>\psi(\Omega)</math> 终于可以被放进 <math>C_1(\Omega+1)</math> 里面了。结果是 <math>\psi(\Omega+1)=\psi(\Omega)\times\omega</math>。后面再一次向上增长,直到 <math>\alpha\rightarrow\psi(\Omega+\alpha)</math> 的不动点。从这里到 <math>\psi(\Omega+\Omega)</math> 又是一段平台期。直到 <math>\psi(\Omega+\Omega+1)</math> 再次恢复增长。


直到<math>\psi(\Omega+1)</math>才迎来了转机。因为<math>\Omega</math>也在<math>C_0(x)</math>里面,因此<math>\psi(\Omega)</math>终于可以被放进<math>C_1(\Omega+1)</math>里面了。结果是<math>\psi(\Omega+1)=\psi(\Omega)\times\omega</math>.后面再一次向上增长,直到<math>\alpha\rightarrow\psi(\Omega+\alpha)</math>的不动点。从这里到<math>\psi(\Omega+\Omega)</math>又是一段平台期。直到<math>\psi(\Omega+\Omega+1)</math>再次恢复增长。
这样的定义可以一直运行到 <math>\psi(\Omega\times\omega)</math>,再往后走不下去了。可是它相比其他[[序数记号]],如 [[Veblen函数]]依然是孱弱的。为了继续前进,我们需要引入更多的非递归序数。


这样的定义可以一直运行到<math>\psi(\Omega\times\omega)</math>,再往后走不下去了。可是它相比其他[[序数记号]],如[[veblen函数]]依然是孱弱的。为了继续前进,我们需要引入更多的非递归序数。
==== 更多的非递归序数 ====
 
下面是引入更多非递归序数的 BOCF 定义:
=== 更多的非递归序数 ===
下面是引入更多非递归序数的BOCF定义:


# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|v<\beta<\omega\}</math>
# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|v<\beta<\omega\}</math>
第95行: 第85行:
# <math>\psi_v(x)=min\{\alpha<\Omega_{v+1}|\alpha\notin C^v(x)\}</math>
# <math>\psi_v(x)=min\{\alpha<\Omega_{v+1}|\alpha\notin C^v(x)\}</math>


<math>\psi</math>函数即<math>\psi_0</math>函数。
<math>\psi</math> 函数即 <math>\psi_0</math> 函数。
 
可以看到,根据定义,有<math>C_0^1(0)=\{\alpha,\Omega_2|\alpha<\Omega\}</math>,随后<math>C_n^1(0)</math>是根据<math>C_0^1(0)=\{\alpha,\Omega_2|\alpha<\Omega\}</math>中元素进行加法所得到的所有东西,注意到它们内部依然不存在<math>\Omega\sim\Omega_2</math>的序数。因此,<math>\psi_1(0)=\Omega</math>.对于<math>\psi_1(1)</math>,因为它可以把<math>\psi_1(0)</math>塞进C里,因此,最后有<math>\psi_1(1)=\Omega\times\omega</math>.之后的内容是顺理成章的,类似<math>\psi(0)\sim\psi(\psi(\psi(\cdots)))</math>的过程,有<math>\psi_1(\psi_1(\psi_1(\cdots)))=\Omega^{\Omega^{\Omega^{\cdots}}}</math>.我们暂时记<math>\psi_1(1,0)=\alpha\rightarrow\psi_1(\alpha)</math>的不动点。可以验证,对于<math>\psi_1</math>函数来说,这里依然存在<math>\psi_1(1,0)<\alpha<\Omega_2</math>的平台期。后面的一切都是顺理成章的。直到任意的<math>\psi_n</math>,都是一样的。
 
但有一点需要注意,对于<math>\psi</math>函数来说,<math>\psi(\psi_1(\Omega_2))</math>并没有打破从<math>\psi(\psi_1(1,0))</math>开始的平台期,这个平台期继续向前,直到<math>\psi(\Omega_2)</math>才结束。这一现象称为'''藏层'''。


BOCF的<math>\psi(\Omega_{\omega})=sup\{\psi(\Omega),\psi(\Omega_2),\psi(\Omega_3,\cdots\}</math>,这一序数有一个名字是[[BO]](Buchholz's Ordinal ),在[[googology]]中是一个非常重要的序数。
可以看到,根据定义,有 <math>C_0^1(0)=\{\alpha,\Omega_2|\alpha<\Omega\}</math>,随后 <math>C_n^1(0)</math> 是根据 <math>C_0^1(0)=\{\alpha,\Omega_2|\alpha<\Omega\}</math> 中元素进行加法所得到的所有东西,注意到它们内部依然不存在 <math>\Omega\sim\Omega_2</math> 的序数。因此,<math>\psi_1(0)=\Omega</math>。对于 <math>\psi_1(1)</math>,因为它可以把 <math>\psi_1(0)</math> 塞进 C 里,因此,最后有 <math>\psi_1(1)=\Omega\times\omega</math>。之后的内容是顺理成章的,类似 <math>\psi(0)\sim\psi(\psi(\psi(\cdots)))</math> 的过程,有 <math>\psi_1(\psi_1(\psi_1(\cdots)))=\Omega^{\Omega^{\Omega^{\cdots}}}</math>。我们暂时记 <math>\psi_1(1,0)=\alpha\rightarrow\psi_1(\alpha)</math> 的不动点。可以验证,对于 <math>\psi_1</math> 函数来说,这里依然存在 <math>\psi_1(1,0)<\alpha<\Omega_2</math> 的平台期。后面的一切都是顺理成章的。直到任意的 <math>\psi_n</math>,都是一样的。


''tips:OCF中的<math>\Omega</math>不一定非得是[[序数#非递归序数|非递归序数]],它只需要大于'''所有你研究的序数'''就可以了,比方说你想要研究[[Bashicu矩阵|BMS]],那么理论上你只需要保证它大于BMS极限就可以了。但是我们的研究是永无止境的,因此普遍使用非递归序数这一大于所有递归序数的东西来充当<math>\Omega</math>''
但有一点需要注意,对于 <math>\psi</math> 函数来说,<math>\psi(\psi_1(\Omega_2))</math> 并没有打破从 <math>\psi(\psi_1(1,0))</math> 开始的平台期,这个平台期继续向前,直到 <math>\psi(\Omega_2)</math> 才结束。这一现象称为'''藏层'''


=== 直观理解与操作规则 ===
BOCF 的 <math>\psi(\Omega_{\omega})=sup\{\psi(\Omega),\psi(\Omega_2),\psi(\Omega_3,\cdots\}</math>,这一序数有一个名字是[[BO]](Buchholz's Ordinal ),在[[googology]]中是一个非常重要的序数。


让我们从<math>\psi(0)=1</math>开始。
''tips:OCF中的 <math>\Omega</math> 不一定非得是[[序数#非递归序数|非递归序数]],它只需要大于'''所有你研究的序数'''就可以了,比方说你想要研究 [[Bashicu矩阵|BMS]],那么理论上你只需要保证它大于 BMS 极限就可以了。但是我们的研究是永无止境的,因此普遍使用非递归序数这一大于所有递归序数的东西来充当 <math>\Omega</math>。''


BOCF有这样的性质:
==== 直观理解与操作规则 ====
让我们从 <math>\psi(0)=1</math> 开始。


<math>\psi(m+1)=\psi(m)\times\omega</math>,m是任意序数
BOCF 有这样的性质:


因此,可以得到<math>\psi(1)=\omega</math>。得到之后,你对<math>\psi(1)</math>之前的序数已经很清楚了,于是,可以把这些序数也都放进<math>\psi</math>函数内部,于是,你最大能得到<math>\psi(\psi(1))=\psi(\omega)=\omega^{\omega}</math>.得到它之后,你又对它之前的序数很清楚了,于是又可以把它们也放进<math>\psi</math>函数内部,最大能得到<math>\psi(\psi(\psi(1)))=\omega^{\omega^{\omega}}</math>……以此类推,你可以得到嵌套任意多层的<math>\psi(\psi(\psi(\cdots)))</math>.
<math>\psi(m+1)=\psi(m)\times\omega</math>,m 是任意序数。


这个时候,我们的新朋友<math>\Omega</math>出场了。我们令<math>\psi(\Omega)=\psi(\psi(\psi(\cdots)))</math>,于是我们可以继续:<math>\psi(\Omega+1)=\psi(\Omega)\times\omega</math>.现在你会发现,它内部既然可以加一,那是不是也可以加上更大的序数呢?答案是肯定的。你先前已经得到了<math>\psi(\Omega)</math>,那么对它之前的序数已经清楚了。于是只需要重走一遍1到<math>\psi(\Omega)</math>的路,就可以得到<math>\psi(\Omega+\psi(\Omega))</math>.和前面类似的,得到<math>\color{red}\psi(\Omega+\psi(\Omega))</math>后,也就可以理解<math>\psi(\Omega+{\color{red}\psi(\Omega+\psi(\Omega))})</math>,毕竟只是在<math>\psi</math>内重走一遍先前走过的路。上面的路又可以一直走下去,直到<math>\psi(\Omega+\psi(\Omega+\psi(\Omega+\cdots)))</math>.
因此,可以得到 <math>\psi(1)=\omega</math>。得到之后,你对 <math>\psi(1)</math> 之前的序数已经很清楚了,于是,可以把这些序数也都放进 <math>\psi</math> 函数内部,于是,你最大能得到 <math>\psi(\psi(1))=\psi(\omega)=\omega^{\omega}</math>。得到它之后,你又对它之前的序数很清楚了,于是又可以把它们也放进 <math>\psi</math> 函数内部,最大能得到 <math>\psi(\psi(\psi(1)))=\omega^{\omega^{\omega}}</math>……以此类推,你可以得到嵌套任意多层的 <math>\psi(\psi(\psi(\cdots)))</math>


于是,<math>\Omega</math>再次登场,它让<math>\psi(\Omega+\psi(\Omega+\psi(\Omega+\cdots)))=\psi(\Omega+\Omega)=\psi(\Omega\times2)</math>.我们又可以按先前的思路,首先得到<math>\psi(\Omega\times2+1)=\psi(\Omega\times2)\times\omega</math>,然后重走一遍1到<math>\psi(\Omega\times2)</math>的路,就得到<math>\psi(\Omega\times2+\psi(\Omega\times2))</math>;再重走一遍<math>\psi(\Omega\times2)</math><math>\psi(\Omega\times2+\psi(\Omega\times2))</math>的路,就得到<math>\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2)))</math>,再以此类推,得到<math>\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2+\cdots)))</math>后再把它变成<math>\psi(\Omega\times3)</math>,然后再……
这个时候,我们的新朋友 <math>\Omega</math> 出场了。我们令 <math>\psi(\Omega)=\psi(\psi(\psi(\cdots)))</math>,于是我们可以继续:<math>\psi(\Omega+1)=\psi(\Omega)\times\omega</math>。现在你会发现,它内部既然可以加一,那是不是也可以加上更大的序数呢?答案是肯定的。你先前已经得到了 <math>\psi(\Omega)</math>,那么对它之前的序数已经清楚了。于是只需要重走一遍 1 到 <math>\psi(\Omega)</math> 的路,就可以得到 <math>\psi(\Omega+\psi(\Omega))</math>。和前面类似的,得到 <math>\color{red}\psi(\Omega+\psi(\Omega))</math> 后,也就可以理解 <math>\psi(\Omega+{\color{red}\psi(\Omega+\psi(\Omega))})</math>,毕竟只是在 <math>\psi</math> 内重走一遍先前走过的路。上面的路又可以一直走下去,直到 <math>\psi(\Omega+\psi(\Omega+\psi(\Omega+\cdots)))</math>


说到这里,读者应该对<math>\Omega</math>有一定的认识了。它的“能力”是让'''包着它的一层'''<math>\psi</math>函数连同内部的其他内容一起嵌套n层。如<math>\psi(\Omega\times3)=\psi(\Omega\times2+\Omega)=\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2+\cdots)))</math>.细心的读者可能注意到,这其实是[[不动点]]的体现。没错,OCF中的<math>\Omega</math>可以说是不动点的“化身”,只要它出现,就一定是代表了一个不动点。事实上,前文只展示了加法。<math>\Omega</math>对于乘法和乘方所做的事情和加法是如出一辙的,以下是例子:
于是,<math>\Omega</math> 再次登场,它让 <math>\psi(\Omega+\psi(\Omega+\psi(\Omega+\cdots)))=\psi(\Omega+\Omega)=\psi(\Omega\times2)</math>。我们又可以按先前的思路,首先得到 <math>\psi(\Omega\times2+1)=\psi(\Omega\times2)\times\omega</math>,然后重走一遍 1 到 <math>\psi(\Omega\times2)</math> 的路,就得到 <math>\psi(\Omega\times2+\psi(\Omega\times2))</math>;再重走一遍 <math>\psi(\Omega\times2)</math> 到 <math>\psi(\Omega\times2+\psi(\Omega\times2))</math> 的路,就得到 <math>\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2)))</math>,再以此类推,得到 <math>\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2+\cdots)))</math> 后再把它变成 <math>\psi(\Omega\times3)</math>,然后再……


得到<math>\psi(\Omega\times\omega)</math>,理解加一个<math>\Omega</math>起到什么作用之后,只需要重走一边<math>\omega</math>到<math>\psi(\Omega)</math>的路,就能得到<math>\psi(\Omega\times\psi(\Omega))</math>,然后再重走一遍<math>\psi(\Omega)</math>到<math>\psi(\Omega\times\psi(\Omega))</math>的路,就能得到<math>\psi(\Omega\times\psi(\Omega\times\psi(\Omega)))</math>……最后得到<math>\psi(\Omega^2)=\psi(\Omega\times\Omega)=\psi(\Omega\times\psi(\Omega\times\psi(\Omega\times\cdots)))</math>.
说到这里,读者应该对 <math>\Omega</math> 有一定的认识了。它的“能力”是让'''包着它的一层'''<math>\psi</math> 函数连同内部的其他内容一起嵌套 n 层。如 <math>\psi(\Omega\times3)=\psi(\Omega\times2+\Omega)=\psi(\Omega\times2+\psi(\Omega\times2+\psi(\Omega\times2+\cdots)))</math>。细心的读者可能注意到,这其实是[[不动点]]的体现。没错,OCF 中的 <math>\Omega</math> 可以说是不动点的“化身”,只要它出现,就一定是代表了一个不动点。事实上,前文只展示了加法。<math>\Omega</math> 对于乘法和乘方所做的事情和加法是如出一辙的,以下是例子:


得到 <math>\psi(\Omega\times\omega)</math>,理解加一个 <math>\Omega</math> 起到什么作用之后,只需要重走一遍 <math>\omega</math> 到 <math>\psi(\Omega)</math> 的路,就能得到 <math>\psi(\Omega\times\psi(\Omega))</math>,然后再重走一遍 <math>\psi(\Omega)</math> 到 <math>\psi(\Omega\times\psi(\Omega))</math> 的路,就能得到 <math>\psi(\Omega\times\psi(\Omega\times\psi(\Omega)))</math>……最后得到 <math>\psi(\Omega^2)=\psi(\Omega\times\Omega)=\psi(\Omega\times\psi(\Omega\times\psi(\Omega\times\cdots)))</math>。


得到<math>\psi(\Omega^3)</math>,理解加一个<math>\Omega^2</math>起到什么作用之后,只需要重走一边1到<math>\psi(\Omega^3)</math>的路,就能从<math>\psi(\Omega^3+\Omega^2\times1)</math>开始得到<math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3))</math>,然后再重走一遍<math>\psi(\Omega^3)</math>到<math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3))</math>的路,就能得到<math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\psi(\Omega^3)))</math>……最后得到<math>\psi(\Omega^3\times2)=\psi(\Omega^3+\Omega^2\times\Omega)=\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\cdots)))</math>.
得到 <math>\psi(\Omega^3)</math>,理解加一个 <math>\Omega^2</math> 起到什么作用之后,只需要重走一遍 1 到 <math>\psi(\Omega^3)</math> 的路,就能从 <math>\psi(\Omega^3+\Omega^2\times1)</math> 开始得到 <math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3))</math>,然后再重走一遍 <math>\psi(\Omega^3)</math> 到 <math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3))</math> 的路,就能得到 <math>\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\psi(\Omega^3)))</math>……最后得到 <math>\psi(\Omega^3\times2)=\psi(\Omega^3+\Omega^2\times\Omega)=\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\psi(\Omega^3+\Omega^2\times\cdots)))</math>


得到<math>\psi(\Omega^{\Omega^{\Omega}})</math>和<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^1})</math>,只需要重走一边1到<math>\psi(\Omega^{\Omega^{\Omega}})</math>的路,就能从<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^1})</math>开始得到<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})</math>,然后再重走一遍<math>\psi(\Omega^{\Omega^{\Omega}})</math>到<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})</math>路,就能得到<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})}})</math>……最后得到<math>\psi(\Omega^{\Omega^{\Omega}\times2})=\psi(\Omega^{\Omega^{\Omega}+\Omega^{\Omega}})=\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\cdots}})}})}})</math>.
得到<math>\psi(\Omega^{\Omega^{\Omega}})</math> 和 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^1})</math>,只需要重走一边 1 到 <math>\psi(\Omega^{\Omega^{\Omega}})</math> 的路,就能从 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^1})</math> 开始得到 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})</math>,然后再重走一遍 <math>\psi(\Omega^{\Omega^{\Omega}})</math> 到 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})</math> 路,就能得到 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}})}})}})</math>……最后得到 <math>\psi(\Omega^{\Omega^{\Omega}\times2})=\psi(\Omega^{\Omega^{\Omega}+\Omega^{\Omega}})=\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\psi(\Omega^{\Omega^{\Omega}+\Omega^{\cdots}})}})}})</math>


以下是[[BHO]](即<math>\psi(\Omega^{\Omega^{\Omega^{\cdots}}})</math>)之前的BOCF的操作规则:
以下是 [[BHO]](即 <math>\psi(\Omega^{\Omega^{\Omega^{\cdots}}})</math>)之前的 BOCF 的操作规则:


<math>\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(0)=\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+1</math>
* <math>\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(0)=\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+1</math>
* <math>(\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(\alpha_n))[m]=\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(\alpha_m)[m]</math>
* <math>\psi(X+1)[m]=\psi(X)\times m</math>
* <math>\psi(X+\psi(Y))[m]=\psi(X+\psi(Y)[m])</math>


<math>(\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(\alpha_n))[m]=\psi(\alpha_1)+\psi(\alpha_2)+\cdots+\psi(\alpha_{n-1})+\psi(\alpha_m)[m]</math>
这四条和康托范式的规则是一样的,主要是要找准表达式最右侧的结构。如果最右侧是外面的 1 那就是后继,最右侧是 <math>\psi</math> 里面的 1 那就是乘 <math>\omega</math>。最右侧如果是 <math>\psi(X)</math>,则先操作它。


<math>\psi(X+1)[m]=\psi(X)\times m</math>
但如果最右侧是 <math>\Omega</math> 呢?很简单,只需要找到包着它的那一层 <math>\psi</math>,然后在原位嵌套即可。即:


<math>\psi(X+\psi(Y))[m]=\psi(X+\psi(Y)[m])</math>
<math>\psi(Z\sim\Omega)=\psi(Z\sim\psi(Z\sim\psi(Z\sim\cdots)))</math>,其中 ~ 是 + 或者 × 或者 ^。注意这里的 Z 并不一定是一个序数,它可以只是一个算式。比如说 <math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\Omega}})</math> 对应的 Z 是<math>\psi({\color{red}\Omega^{\Omega^{\Omega}+\Omega^{\color{black}\Omega}}})</math> 标红的部分。


这四条和康托范式的规则是一样的,主要是要找准表达式最右侧的结构。如果最右侧是外面的1那就是后继,最右侧是<math>\psi</math>里面的1那就是乘<math>\omega</math>。最右侧如果是<math>\psi(X)</math>,则先操作它。
有的时候最右侧的 <math>\Omega</math> 被藏起来,你需要自己去挖掘出来。比方说 <math>\psi(\Omega^3\times2)</math>,你需要把它写成 <math>\psi(\Omega^3+\Omega^2\times\Omega)</math> 这种形式。


但如果最右侧是<math>\Omega</math>呢?很简单,只需要找到包着它的那一层<math>\psi</math>,然后在原位嵌套即可。即:
''tips:BOCF 中实际上并不存在乘法和乘方,因此上文的大部分式子严格来说是不标准的。但是在 googology 绝大多种情况下,为了方便和清晰性,我们都会用这种“部分”引入乘法和乘方的 BOCF 不标准式。''


<math>\psi(Z\sim\Omega)=\psi(Z\sim\psi(Z\sim\psi(Z\sim\cdots)))</math>,其中~是+或者×或者^。注意这里的Z并不一定是一个序数,它可以只是一个算式。比如说<math>\psi(\Omega^{\Omega^{\Omega}+\Omega^{\Omega}})</math>对应的Z是<math>\psi({\color{red}\Omega^{\Omega^{\Omega}+\Omega^{\color{black}\Omega}}})</math>标红的部分。
BHO 之上,就需要引入更多的非递归序数 <math>\Omega_2,\Omega_3,\Omega_4,\cdots</math>。对于他们来说,有 <math>\psi_1</math> 函数,<math>\psi_2</math> 函数,<math>\psi_3</math> 函数……分别对应,<math>\Omega_{m+1}</math> 和 <math>\psi_m</math> 函数之间的关系与 Ω 和 ψ 函数的关系是一模一样的。(<math>\psi</math> 函数即 <math>\psi_0</math> 函数,<math>\Omega</math> 即 <math>\Omega_1</math>


有的时候最右侧的<math>\Omega</math>被藏起来,你需要自己去挖掘出来。比方说<math>\psi(\Omega^3\times2)</math>,你需要把它写成<math>\psi(\Omega^3+\Omega^2\times\Omega)</math>这种形式。
对于 <math>\psi_m</math> 函数,有如下规则:


''tips:BOCF中实际上并不存在乘法和乘方,因此上文的大部分式子严格来说是不标准的。但是在googology绝大多种情况下,为了方便和清晰性,我们都会用这种“部分”引入乘法和乘方的BOCF不标准式。''
* <math>\psi_m(0)=\Omega_m</math>
* <math>\psi_m(X+1)=\psi_m(X)\times\omega</math>
* <math>\psi_m(Y\sim\Omega_{m+1})=\psi_m(Y\sim\psi_m(Y\sim\psi_m(Y\sim\cdots)))</math>


BHO之上,就需要引入更多的非递归序数<math>\Omega_2,\Omega_3,\Omega_4,\cdots</math>.对于他们来说,有<math>\psi_1</math>函数,<math>\psi_2</math>函数,<math>\psi_3</math>函数……分别对应,<math>\Omega_{m+1}</math>和<math>\psi_m</math>函数之间的关系与Ω和ψ函数的关系是一模一样的。(<math>\psi</math>函数即<math>\psi_0</math>函数,<math>\Omega</math>即<math>\Omega_1</math>)
不难发现和 <math>\psi</math> 函数的操作规则几乎一模一样。


对于<math>\psi_m</math>函数,有如下规则:
比如说,有 <math>\psi_1(0)=\Omega</math>,<math>\psi_1(1)=\Omega\times\omega</math>,<math>\psi_1(\psi_1(0))=\Omega^2</math>,<math>\psi_1(\psi_1(0)\times2)=\Omega^3</math>,<math>\psi_1(\psi_1(\psi_1(0)))=\Omega^{\Omega}</math> 等等。最后会得到 <math>\psi_1(\Omega_2)=\psi_1(\psi_1(\psi_1(\cdots)))=\Omega^{\Omega^{\Omega^{\cdots}}}</math>。借助 <math>\psi_1</math> 函数,我们确实突破了前面 BHO 的界限。但事情还没这么简单。


<math>\psi_m(0)=\Omega_m</math>
因为 OCF 存在一个“藏层”现象。即,<math>\psi(\psi_1(\Omega_2))</math> 这样的式子是不标准的,它等价于 <math>\psi(\Omega_2)</math>。相当于那个 <math>\psi_1</math> 的层被“藏起来”了,因此称为藏层。


<math>\psi_m(X+1)=\psi_m(X)\times\omega</math>
根据前文所说,<math>\Omega_n</math> 是一定要找 <math>\psi_{n-1}</math> 函数去嵌套的。那么,面对藏层,我们要如何操作呢?


<math>\psi_m(Y\sim\Omega_{m+1})=\psi_m(Y\sim\psi_m(Y\sim\psi_m(Y\sim\cdots)))</math>
答案是,找到包着 <math>\Omega_n</math> 的最近的 <math>\psi_m</math> 函数满足 <math>m < n</math>,我们视作 <math>\psi_{n-1}</math> 函数被藏在了这个 <math>\psi_m</math> 内部。随后进行嵌套,但要在嵌套过程中把内部的 <math>\psi_m</math> 改成 <math>\psi_{n-1}</math>,即:
 
不难发现和<math>\psi</math>函数的操作规则几乎一模一样
 
比如说,有<math>\psi_1(0)=\Omega</math>,<math>\psi_1(1)=\Omega\times\omega</math>,<math>\psi_1(\psi_1(0))=\Omega^2</math>,<math>\psi_1(\psi_1(0)\times2)=\Omega^3</math>,<math>\psi_1(\psi_1(\psi_1(0)))=\Omega^{\Omega}</math>等等。最后会得到<math>\psi_1(\Omega_2)=\psi_1(\psi_1(\psi_1(\cdots)))=\Omega^{\Omega^{\Omega^{\cdots}}}</math>.借助<math>\psi_1</math>函数,我们确实突破了前面BHO 的界限。但事情还没这么简单。
 
因为OCF存在一个“藏层”现象。即,<math>\psi(\psi_1(\Omega_2))</math>这样的式子是不标准的,它等价于<math>\psi(\Omega_2)</math>.相当于那个<math>\psi_1</math>的层被“藏起来”了,因此称为藏层。
 
根据前文所说,<math>\Omega_n</math>是一定要找<math>\psi_{n-1}</math>函数去嵌套的。那么,面对藏层,我们要如何操作呢?
 
答案是,找到包着<math>\Omega_n</math>的最近的<math>\psi_m</math>函数满足<math>m < n</math>,我们视作<math>\psi_{n-1}</math>函数被藏在了这个<math>\psi_m</math>内部。随后进行嵌套,但要在嵌套过程中把内部的<math>\psi_m</math>改成<math>\psi_{n-1}</math>,即:


<math>\psi_m(Y\sim\Omega_n)=\psi_m(Y\sim\psi_{n-1}(Y\sim\psi_{n-1}(Y\sim\cdots)))</math>
<math>\psi_m(Y\sim\Omega_n)=\psi_m(Y\sim\psi_{n-1}(Y\sim\psi_{n-1}(Y\sim\cdots)))</math>


举例,考虑<math>\psi(\Omega_3+\psi_2(\Omega_3+\Omega_2))</math>,最右端是<math>\Omega_2</math>,它要找一个最近的<math>\psi_n</math>函数满足n<2,是最外层的ψ函数。于是我们按照操作规则得到展开式为<math>\psi(\Omega_3+\psi_2(\Omega_3+\psi_1(\Omega_3+\psi_2(\Omega_3+\psi_1(\Omega_3+\psi_2(\Omega_3+\cdots))))))</math>.
举例,考虑 <math>\psi(\Omega_3+\psi_2(\Omega_3+\Omega_2))</math>,最右端是 <math>\Omega_2</math>,它要找一个最近的 <math>\psi_n</math> 函数满足 n<2,是最外层的 ψ 函数。于是我们按照操作规则得到展开式为 <math>\psi(\Omega_3+\psi_2(\Omega_3+\psi_1(\Omega_3+\psi_2(\Omega_3+\psi_1(\Omega_3+\psi_2(\Omega_3+\cdots))))))</math>


BO是<math>\psi(\Omega_{\omega})</math>,它的[[基本列]]是<math>\{\psi(0),\psi(\Omega),\psi(\Omega_2),\psi(\Omega_3),\psi(\Omega_4),\cdots\}</math>.从这条基本列中的元素开始按照操作规则展开所得到的式子就是标准的,如果得不到,则是不标准的。
BO 是 <math>\psi(\Omega_{\omega})</math>,它的[[基本列]]是 <math>\{\psi(0),\psi(\Omega),\psi(\Omega_2),\psi(\Omega_3),\psi(\Omega_4),\cdots\}</math>。从这条基本列中的元素开始按照操作规则展开所得到的式子就是标准的,如果得不到,则是不标准的。


以上就是BO前的BOCF的直观理解与操作规则。
以上就是 BO 前的 BOCF 的直观理解与操作规则。


=== 枚举 ===
==== 枚举 ====
参见词条[[BOCF VS veblen函数]]
参见词条 [[BOCF VS veblen函数|BOCF VS Veblen 函数]]


== MOCF ==
=== MOCF ===
下面是MOCF的数学定义:
下面是 MOCF 的数学定义:


# <math>C_0(x)=\{0,1,\omega,\Omega\}</math>
# <math>C_0(x)=\{0,1,\omega,\Omega\}</math>
第187行: 第170行:
# <math>\psi(x)=min\{\alpha<\Omega|\alpha\notin C(x)\}</math>
# <math>\psi(x)=min\{\alpha<\Omega|\alpha\notin C(x)\}</math>


可以发现,MOCF和BOCF不同的点在于它把加法、乘法和乘方都放进了<math>C(x)</math>中,而BOCF只有加法。因此,MOCF的<math>\psi(0)=\varepsilon_0</math>,并且有<math>\psi(X+1)=\psi(X)^{\psi(X)^{\psi(X)^{\cdots}}}</math>。在出现<math>\Omega</math>的地方,两种OCF是一样的,如平台期等概念,二者也是一样的。
可以发现,MOCF 和 BOCF 不同的点在于它把加法、乘法和乘方都放进了 <math>C(x)</math> 中,而 BOCF 只有加法。因此,MOCF 的 <math>\psi(0)=\varepsilon_0</math>,并且有 <math>\psi(X+1)=\psi(X)^{\psi(X)^{\psi(X)^{\cdots}}}</math>。在出现 <math>\Omega</math> 的地方,两种 OCF 是一样的,如平台期等概念,二者也是一样的。


下面是引入更多非递归序数的MOCF定义:
下面是引入更多非递归序数的 MOCF 定义:


# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|\beta<\omega\}</math>
# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|\beta<\omega\}</math>
第196行: 第179行:
# <math>\psi_v(x)=min\{\alpha<\Omega_{v+1}|\alpha\notin C^v(x)\}</math>
# <math>\psi_v(x)=min\{\alpha<\Omega_{v+1}|\alpha\notin C^v(x)\}</math>


可以看到和BOCF的定义大差不差,唯一的区别是乘法和乘方的引入。因而操作规则无太大差异,除了<math>\psi_v(X+1)=\psi_v(X)^{\psi_v(X)^{\psi_v(X)^{\cdots}}}</math>.此处不再赘述。
可以看到和 BOCF 的定义大差不差,唯一的区别是乘法和乘方的引入。因而操作规则无太大差异,除了 <math>\psi_v(X+1)=\psi_v(X)^{\psi_v(X)^{\psi_v(X)^{\cdots}}}</math>。此处不再赘述。
 
MOCF的<math>\psi(\Omega_\omega)</math>也是BO。
 
=== 枚举 ===
参见词条[[BOCF VS MOCF]]


== BO之后 ==
MOCF 的 <math>\psi(\Omega_\omega)</math> 也是 BO。
<math>\psi(\Omega_{\omega})</math>之后,googologist们实际上已经不再关注其数学定义,因此这里只介绍操作规则。


BOCF中,我们对每个后继序数<math>\alpha+1</math>对应的<math>\Omega_{\alpha+1}</math>都定义出<math>\psi_{\alpha}</math>函数满足<math>\psi_{\alpha}(0)=\Omega_{\alpha}</math>和<math>\psi_{\alpha}(X+1)=\psi_{\alpha}(X)\times\omega</math>.MOCF中则是<math>\psi_{\alpha}(0)=\Omega_{\alpha}\uparrow\uparrow\omega</math>和<math>\psi_{\alpha}(X+1)=\psi_{\alpha}(X)\uparrow\uparrow\omega</math>.如果β是个极限序数,则没有对应的<math>\psi</math>函数。
==== 枚举 ====
参见词条 [[BOCF VS MOCF]]。


那么,对于类似<math>\Omega_{\Omega^{\Omega}}</math>或<math>\Omega_{\Omega_3\times3}</math>的东西,又要如何处理呢?答案是把下标也看做一个运算,如<math>\Omega_\Omega</math>被看做Ω_Ω。展开过程中找最右侧的<math>\Omega_\alpha</math>时找的是下标的<math>\Omega</math>而非整体的<math>\Omega_\Omega</math>.换句话说,“找最右侧的<math>\Omega_\alpha</math>”本身就要求α一定小于<math>\Omega</math>。
=== BO之后 ===
<math>\psi(\Omega_{\omega})</math> 之后,googologist 们实际上已经不再关注其数学定义,因此这里只介绍操作规则。


以下是补充的操作规则
BOCF 中,我们对每个后继序数 <math>\alpha+1</math> 对应的 <math>\Omega_{\alpha+1}</math> 都定义出 <math>\psi_{\alpha}</math> 函数满足 <math>\psi_{\alpha}(0)=\Omega_{\alpha}</math> 和 <math>\psi_{\alpha}(X+1)=\psi_{\alpha}(X)\times\omega</math>。MOCF 中则是 <math>\psi_{\alpha}(0)=\Omega_{\alpha}\uparrow\uparrow\omega</math> 和 <math>\psi_{\alpha}(X+1)=\psi_{\alpha}(X)\uparrow\uparrow\omega</math>。如果 β 是个极限序数,则没有对应的 <math>\psi</math> 函数。


<math>\psi(X\sim\Omega_{\alpha+1})[m]=\underbrace{\psi(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\cdots}_{m~layers}))))</math>,α为任意序数,~代表+或×或^或下标。
那么,对于类似 <math>\Omega_{\Omega^{\Omega}}</math> 或 <math>\Omega_{\Omega_3\times3}</math> 的东西,又要如何处理呢?答案是把下标也看做一个运算,如 <math>\Omega_\Omega</math> 被看做Ω<sub>Ω</sub>。展开过程中找最右侧的 <math>\Omega_\alpha</math> 时找的是下标的 <math>\Omega</math> 而非整体的 <math>\Omega_\Omega</math>。换句话说,“找最右侧的 <math>\Omega_\alpha</math>”本身就要求 α 一定小于 <math>\Omega</math>


<math>\psi(X\sim\Omega_\beta)[m]=\psi(X\sim\Omega_{\beta[m]})</math>,如果β是极限序数。
以下是补充的操作规则:


这套规则可以一直运用到<math>\psi(\Omega_{\Omega_{\Omega_{\cdots}}})</math>,这个序数称为[[EBO]](Extended Buchholz's Ordinal,扩展布赫霍兹序数)。如果想要继续前进,就需要新的非递归序数了,它们会给出它们对应的折叠规则。具体则需要参见对应词条。
<math>\psi(X\sim\Omega_{\alpha+1})[m]=\underbrace{\psi(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\cdots}_{m~layers}))))</math>,α 为任意序数,~ 代表 + 或 × 或 ^ 或下标。


那么在这里,我们实际上可以说,OCF本身是一个和[[增长层级]]类似的“壳子”,它们接受对应的非递归序数,然后输出大的递归序数。那么,为什么OCF没有像增长层级(如FGH)一样占据googology的所有空间呢?有两方面原因。
<math>\psi(X\sim\Omega_\beta)[m]=\psi(X\sim\Omega_{\beta[m]})</math>,如果 β 是极限序数。


第一方面,OCF没有像增长层级一样具有非常明确的转化规则。googology社区有一个“俗话”——1000个人有1001种[[递归马洛序数|Mahlo]] OCF。这种共识的缺乏是致命的。
这套规则可以一直运用到 <math>\psi(\Omega_{\Omega_{\Omega_{\cdots}}})</math>,这个序数称为 [[EBO]]。如果想要继续前进,就需要新的非递归序数了,它们会给出它们对应的折叠规则。具体则需要参见对应词条。


第二方面,对于目前的googology爱好者来说,构造非递归序数的难度和构造其他类型序数记号,如[[Beklemishev's Worm|Worm]]型记号,相比,在难度上拉不开差距。不像FGH加序数记号对传统数阵记号的“降维打击”。而且,googology爱好者普遍没有很强的数理逻辑或序数分析基础,难以理解和运用学界所构造的大可数序数。
那么在这里,我们实际上可以说,OCF 本身是一个和[[增长层级]]类似的“壳子”,它们接受对应的非递归序数,然后输出大的递归序数。那么,为什么 OCF 没有像增长层级(如 FGH)一样占据 googology 的所有空间呢?有两方面原因。


但我还是希望,伴随着googology爱好者水平不断提高,有一天OCF加大非递归序数会占据googology的主流,而Worm型记号会像曾经的数阵记号一样被边缘化。如果是这样,那对于googology来说,就是不亚于2014年的大飞跃发展了。
第一方面,OCF 没有像增长层级一样具有非常明确的转化规则。googology 社区有一个“俗话”——1000 个人有 1001 种 [[递归马洛序数|Mahlo]] OCF。这种共识的缺乏是致命的。


第二方面,对于目前的 googology 爱好者来说,构造非递归序数的难度和构造其他类型序数记号,如 [[Beklemishev's Worm|Worm]] 型记号,相比,在难度上拉不开差距。不像 FGH 加序数记号对传统数阵记号的“降维打击”。而且,googology 爱好者普遍没有很强的数理逻辑或序数分析基础,难以理解和运用学界所构造的大可数序数。


但我还是希望,伴随着 googology 爱好者水平不断提高,有一天 OCF 加大非递归序数会占据 googology 的主流,而 Worm 型记号会像曾经的数阵记号一样被边缘化。如果是这样,那对于 googology 来说,就是不亚于 2014 年的大飞跃发展了。


[[分类:记号]]
[[分类:记号]]
[[分类:入门]]
[[分类:入门]]

2025年7月28日 (一) 11:36的版本

序数塌缩函数(Ordinal Collapsing Function,OCF)是一种序数函数。它们的特点是利用足够大的序数(通常是非递归序数)来输出递归序数。事实上,OCF 有很多不同的版本。本词条着力于介绍 EBO 之前的 BOCF(Buchholz's OCF)和 MOCF(Madore's OCF)。

教学

BOCF 简介

前排提醒:对严谨数学定义不感冒或看不懂的读者可以直接跳到直观理解与操作规则

定义

首先我们给出 BOCF 只引入第一个非递归序数 Ω 的定义:

  1. C0(x)={0,Ω}
  2. Cn+1(x)=Cn(x){α+β,ψ(γ)|α,β,γCn(x),γ<x}
  3. C(x)=n<ωCn(x)
  4. ψ(x)=min{α<Ω|α∉C(x)}

其中的 Ω 要求是一个足够大的序数。以往的资料一般使用第一个不可数序数 ω1 来作为它。但我们发现,第一个非递归序数 ω1CK 已经可以满足我们的需求。因此,目前提到 Ω,默认指的是 ω1CK

这四条规则很是抽象,让我们一条一条来看。

规则 1:C0(x)={0,Ω}。对于任意的 x , C0(x) 是同一个集合。

规则 2,这个规则递归定义了 Cn+1(x),它是 Cn(x) 再加上 Cn(x) 中的元素通过加法和 ψ 函数能产生的所有元素。这里要求 ψ 函数自变量小于 x,因为 ψ(x) 是需要 C(x) 来定义的。

规则3,C(x) 是对所有的 Cn(x) 取并集得到的集合。

规则4,ψ(x) 就是所有小于 Ω 的序数中,不属于 C(x) 的最小序数。

ε0 之前

以下是一些运算实例:

  • C0(0)={0,Ω}
  • C1(0)={0,Ω,Ω×2}
  • C2(0)={0,Ω,Ω×2,Ω×3,Ω×4}
  • ……

C(0)={0,Ω,},省略号省掉了大于 Ω 的序数。

因此 ψ(0) 是最小的小于 Ω 的不在 C(0) 里的序数,即 1。

下一个例子是 ψ(2),假定首先你已经知道了 ψ(1)=ω(可以自己验证),我们要开始计算 ψ(2),还是不展示大于 Ω 的序数:

  • C0(2)={0,Ω}
  • C1(2)={0,ψ(0)=1,Ω,}
  • C2(2) 包含了 1,2 和 ψ(1),即 ω
  • C3(2) 包含了 1,2,3,4,ω,ω+1,ω+2,ω×2

以此类推,最后能得到 C(2) 中包含了全体小于 ω2 的序数和一大堆大于 Ω 的序数。因此根据定义,ψ(2)=ω2

ψ 函数内是极限序数并不影响定义和计算。

你有没有觉得一步一步按定义走太过于繁琐?下面给出它的 2 个性质:

  1. ψ(m+1)=ψ(m)×ω,m 是任意序数
  2. ψ(λ)=sup{ψ(κ)|κ<λ},α 是任意非 0 极限序数

根据这个性质,我们可以轻松的得到:

  • ψ(ω)=ωω=ψ(ψ(1))
  • ψ(ω+1)=ωω+1=ψ(ψ(1)+1)
  • ψ(ω×2)=ωω×2=ψ(ψ(1)×2)
  • ψ(ω2)=ωω2=ψ(ψ(2))
  • ψ(ωω)=ωωω=ψ(ψ(ψ(1)))
  • ψ(ωωω)=ωωωω=ψ(ψ(ψ(ψ(1))))
  • ……

到这里和康托范式Veblen 函数φ(x) 都是一致的。然而,在 ε0 开始,OCF 将与它们分道扬镳。

ε0 与平台期

ε0=αψ(α) 的第一个不动点,这里没有问题。问题出在 ψ(ε0+1) 上。

注意到 C0(ε0+1)={0,Ω}C1(ε0+1) 中小于 Ω 的最大元素是 ψ(0)C2(ε0+1) 中小于 Ω 的最大元素是 ψ(ψ(0))C2(ε0+1) 中小于 Ω 的最大元素是 ψ(ψ(ψ(0)))……

因此,ψ(ε0) 始终无法出现在这里面。这直接导致了 C(ε0+1) 中,小于 Ω 的最小的不在里面的依然是 ψ(ε0),相当于“卡住了”。这意味着对于所有的 ε0αΩ,都有 ψ(α)=ψ(ε0)。这就像一个巨大的平台,因此称为平台期

直到 ψ(Ω+1) 才迎来了转机。因为 Ω 也在 C0(x) 里面,因此 ψ(Ω) 终于可以被放进 C1(Ω+1) 里面了。结果是 ψ(Ω+1)=ψ(Ω)×ω。后面再一次向上增长,直到 αψ(Ω+α) 的不动点。从这里到 ψ(Ω+Ω) 又是一段平台期。直到 ψ(Ω+Ω+1) 再次恢复增长。

这样的定义可以一直运行到 ψ(Ω×ω),再往后走不下去了。可是它相比其他序数记号,如 Veblen函数依然是孱弱的。为了继续前进,我们需要引入更多的非递归序数。

更多的非递归序数

下面是引入更多非递归序数的 BOCF 定义:

  1. C0v(x)={α|α<Ωv}{Ωβ|v<β<ω}
  2. Cn+1v(x)={α+β,ψδ(γ)|α,β,γCnv(x),γ<x,δ<ω}
  3. Cv(x)=n<ωCnv(x)
  4. ψv(x)=min{α<Ωv+1|αCv(x)}

ψ 函数即 ψ0 函数。

可以看到,根据定义,有 C01(0)={α,Ω2|α<Ω},随后 Cn1(0) 是根据 C01(0)={α,Ω2|α<Ω} 中元素进行加法所得到的所有东西,注意到它们内部依然不存在 ΩΩ2 的序数。因此,ψ1(0)=Ω。对于 ψ1(1),因为它可以把 ψ1(0) 塞进 C 里,因此,最后有 ψ1(1)=Ω×ω。之后的内容是顺理成章的,类似 ψ(0)ψ(ψ(ψ())) 的过程,有 ψ1(ψ1(ψ1()))=ΩΩΩ。我们暂时记 ψ1(1,0)=αψ1(α) 的不动点。可以验证,对于 ψ1 函数来说,这里依然存在 ψ1(1,0)<α<Ω2 的平台期。后面的一切都是顺理成章的。直到任意的 ψn,都是一样的。

但有一点需要注意,对于 ψ 函数来说,ψ(ψ1(Ω2)) 并没有打破从 ψ(ψ1(1,0)) 开始的平台期,这个平台期继续向前,直到 ψ(Ω2) 才结束。这一现象称为藏层

BOCF 的 ψ(Ωω)=sup{ψ(Ω),ψ(Ω2),ψ(Ω3,},这一序数有一个名字是BO(Buchholz's Ordinal ),在googology中是一个非常重要的序数。

tips:OCF中的 Ω 不一定非得是非递归序数,它只需要大于所有你研究的序数就可以了,比方说你想要研究 BMS,那么理论上你只需要保证它大于 BMS 极限就可以了。但是我们的研究是永无止境的,因此普遍使用非递归序数这一大于所有递归序数的东西来充当 Ω

直观理解与操作规则

让我们从 ψ(0)=1 开始。

BOCF 有这样的性质:

ψ(m+1)=ψ(m)×ω,m 是任意序数。

因此,可以得到 ψ(1)=ω。得到之后,你对 ψ(1) 之前的序数已经很清楚了,于是,可以把这些序数也都放进 ψ 函数内部,于是,你最大能得到 ψ(ψ(1))=ψ(ω)=ωω。得到它之后,你又对它之前的序数很清楚了,于是又可以把它们也放进 ψ 函数内部,最大能得到 ψ(ψ(ψ(1)))=ωωω……以此类推,你可以得到嵌套任意多层的 ψ(ψ(ψ()))

这个时候,我们的新朋友 Ω 出场了。我们令 ψ(Ω)=ψ(ψ(ψ())),于是我们可以继续:ψ(Ω+1)=ψ(Ω)×ω。现在你会发现,它内部既然可以加一,那是不是也可以加上更大的序数呢?答案是肯定的。你先前已经得到了 ψ(Ω),那么对它之前的序数已经清楚了。于是只需要重走一遍 1 到 ψ(Ω) 的路,就可以得到 ψ(Ω+ψ(Ω))。和前面类似的,得到 ψ(Ω+ψ(Ω)) 后,也就可以理解 ψ(Ω+ψ(Ω+ψ(Ω))),毕竟只是在 ψ 内重走一遍先前走过的路。上面的路又可以一直走下去,直到 ψ(Ω+ψ(Ω+ψ(Ω+)))

于是,Ω 再次登场,它让 ψ(Ω+ψ(Ω+ψ(Ω+)))=ψ(Ω+Ω)=ψ(Ω×2)。我们又可以按先前的思路,首先得到 ψ(Ω×2+1)=ψ(Ω×2)×ω,然后重走一遍 1 到 ψ(Ω×2) 的路,就得到 ψ(Ω×2+ψ(Ω×2));再重走一遍 ψ(Ω×2)ψ(Ω×2+ψ(Ω×2)) 的路,就得到 ψ(Ω×2+ψ(Ω×2+ψ(Ω×2))),再以此类推,得到 ψ(Ω×2+ψ(Ω×2+ψ(Ω×2+))) 后再把它变成 ψ(Ω×3),然后再……

说到这里,读者应该对 Ω 有一定的认识了。它的“能力”是让包着它的一层ψ 函数连同内部的其他内容一起嵌套 n 层。如 ψ(Ω×3)=ψ(Ω×2+Ω)=ψ(Ω×2+ψ(Ω×2+ψ(Ω×2+)))。细心的读者可能注意到,这其实是不动点的体现。没错,OCF 中的 Ω 可以说是不动点的“化身”,只要它出现,就一定是代表了一个不动点。事实上,前文只展示了加法。Ω 对于乘法和乘方所做的事情和加法是如出一辙的,以下是例子:

得到 ψ(Ω×ω),理解加一个 Ω 起到什么作用之后,只需要重走一遍 ωψ(Ω) 的路,就能得到 ψ(Ω×ψ(Ω)),然后再重走一遍 ψ(Ω)ψ(Ω×ψ(Ω)) 的路,就能得到 ψ(Ω×ψ(Ω×ψ(Ω)))……最后得到 ψ(Ω2)=ψ(Ω×Ω)=ψ(Ω×ψ(Ω×ψ(Ω×)))

得到 ψ(Ω3),理解加一个 Ω2 起到什么作用之后,只需要重走一遍 1 到 ψ(Ω3) 的路,就能从 ψ(Ω3+Ω2×1) 开始得到 ψ(Ω3+Ω2×ψ(Ω3)),然后再重走一遍 ψ(Ω3)ψ(Ω3+Ω2×ψ(Ω3)) 的路,就能得到 ψ(Ω3+Ω2×ψ(Ω3+Ω2×ψ(Ω3)))……最后得到 ψ(Ω3×2)=ψ(Ω3+Ω2×Ω)=ψ(Ω3+Ω2×ψ(Ω3+Ω2×ψ(Ω3+Ω2×)))

得到ψ(ΩΩΩ)ψ(ΩΩΩ+Ω1),只需要重走一边 1 到 ψ(ΩΩΩ) 的路,就能从 ψ(ΩΩΩ+Ω1) 开始得到 ψ(ΩΩΩ+Ωψ(ΩΩΩ)),然后再重走一遍 ψ(ΩΩΩ)ψ(ΩΩΩ+Ωψ(ΩΩΩ)) 路,就能得到 ψ(ΩΩΩ+Ωψ(ΩΩΩ+Ωψ(ΩΩΩ)))……最后得到 ψ(ΩΩΩ×2)=ψ(ΩΩΩ+ΩΩ)=ψ(ΩΩΩ+Ωψ(ΩΩΩ+Ωψ(ΩΩΩ+Ω)))

以下是 BHO(即 ψ(ΩΩΩ))之前的 BOCF 的操作规则:

  • ψ(α1)+ψ(α2)++ψ(αn1)+ψ(0)=ψ(α1)+ψ(α2)++ψ(αn1)+1
  • (ψ(α1)+ψ(α2)++ψ(αn1)+ψ(αn))[m]=ψ(α1)+ψ(α2)++ψ(αn1)+ψ(αm)[m]
  • ψ(X+1)[m]=ψ(X)×m
  • ψ(X+ψ(Y))[m]=ψ(X+ψ(Y)[m])

这四条和康托范式的规则是一样的,主要是要找准表达式最右侧的结构。如果最右侧是外面的 1 那就是后继,最右侧是 ψ 里面的 1 那就是乘 ω。最右侧如果是 ψ(X),则先操作它。

但如果最右侧是 Ω 呢?很简单,只需要找到包着它的那一层 ψ,然后在原位嵌套即可。即:

ψ(ZΩ)=ψ(Zψ(Zψ(Z))),其中 ~ 是 + 或者 × 或者 ^。注意这里的 Z 并不一定是一个序数,它可以只是一个算式。比如说 ψ(ΩΩΩ+ΩΩ) 对应的 Z 是ψ(ΩΩΩ+ΩΩ) 标红的部分。

有的时候最右侧的 Ω 被藏起来,你需要自己去挖掘出来。比方说 ψ(Ω3×2),你需要把它写成 ψ(Ω3+Ω2×Ω) 这种形式。

tips:BOCF 中实际上并不存在乘法和乘方,因此上文的大部分式子严格来说是不标准的。但是在 googology 绝大多种情况下,为了方便和清晰性,我们都会用这种“部分”引入乘法和乘方的 BOCF 不标准式。

BHO 之上,就需要引入更多的非递归序数 Ω2,Ω3,Ω4,。对于他们来说,有 ψ1 函数,ψ2 函数,ψ3 函数……分别对应,Ωm+1ψm 函数之间的关系与 Ω 和 ψ 函数的关系是一模一样的。(ψ 函数即 ψ0 函数,ΩΩ1

对于 ψm 函数,有如下规则:

  • ψm(0)=Ωm
  • ψm(X+1)=ψm(X)×ω
  • ψm(YΩm+1)=ψm(Yψm(Yψm(Y)))

不难发现和 ψ 函数的操作规则几乎一模一样。

比如说,有 ψ1(0)=Ωψ1(1)=Ω×ω,ψ1(ψ1(0))=Ω2,ψ1(ψ1(0)×2)=Ω3,ψ1(ψ1(ψ1(0)))=ΩΩ 等等。最后会得到 ψ1(Ω2)=ψ1(ψ1(ψ1()))=ΩΩΩ。借助 ψ1 函数,我们确实突破了前面 BHO 的界限。但事情还没这么简单。

因为 OCF 存在一个“藏层”现象。即,ψ(ψ1(Ω2)) 这样的式子是不标准的,它等价于 ψ(Ω2)。相当于那个 ψ1 的层被“藏起来”了,因此称为藏层。

根据前文所说,Ωn 是一定要找 ψn1 函数去嵌套的。那么,面对藏层,我们要如何操作呢?

答案是,找到包着 Ωn 的最近的 ψm 函数满足 m<n,我们视作 ψn1 函数被藏在了这个 ψm 内部。随后进行嵌套,但要在嵌套过程中把内部的 ψm 改成 ψn1,即:

ψm(YΩn)=ψm(Yψn1(Yψn1(Y)))

举例,考虑 ψ(Ω3+ψ2(Ω3+Ω2)),最右端是 Ω2,它要找一个最近的 ψn 函数满足 n<2,是最外层的 ψ 函数。于是我们按照操作规则得到展开式为 ψ(Ω3+ψ2(Ω3+ψ1(Ω3+ψ2(Ω3+ψ1(Ω3+ψ2(Ω3+))))))

BO 是 ψ(Ωω),它的基本列{ψ(0),ψ(Ω),ψ(Ω2),ψ(Ω3),ψ(Ω4),}。从这条基本列中的元素开始按照操作规则展开所得到的式子就是标准的,如果得不到,则是不标准的。

以上就是 BO 前的 BOCF 的直观理解与操作规则。

枚举

参见词条 BOCF VS Veblen 函数

MOCF

下面是 MOCF 的数学定义:

  1. C0(x)={0,1,ω,Ω}
  2. Cn+1(x)={α+β,α×β,αβ,ψ(γ)|α,β,γCn(x)|γ<x}
  3. C(x)=n<ωCn(x)
  4. ψ(x)=min{α<Ω|αC(x)}

可以发现,MOCF 和 BOCF 不同的点在于它把加法、乘法和乘方都放进了 C(x) 中,而 BOCF 只有加法。因此,MOCF 的 ψ(0)=ε0,并且有 ψ(X+1)=ψ(X)ψ(X)ψ(X)。在出现 Ω 的地方,两种 OCF 是一样的,如平台期等概念,二者也是一样的。

下面是引入更多非递归序数的 MOCF 定义:

  1. C0v(x)={α|α<Ωv}{Ωβ|β<ω}
  2. Cn+1v(x)={α+β,α×β,αβ,ψδ(γ)|α,β,γCnv(x),γ<x,δ<ω}
  3. Cv(x)=n<ωCnv(x)
  4. ψv(x)=min{α<Ωv+1|αCv(x)}

可以看到和 BOCF 的定义大差不差,唯一的区别是乘法和乘方的引入。因而操作规则无太大差异,除了 ψv(X+1)=ψv(X)ψv(X)ψv(X)。此处不再赘述。

MOCF 的 ψ(Ωω) 也是 BO。

枚举

参见词条 BOCF VS MOCF

BO之后

ψ(Ωω) 之后,googologist 们实际上已经不再关注其数学定义,因此这里只介绍操作规则。

BOCF 中,我们对每个后继序数 α+1 对应的 Ωα+1 都定义出 ψα 函数满足 ψα(0)=Ωαψα(X+1)=ψα(X)×ω。MOCF 中则是 ψα(0)=Ωαωψα(X+1)=ψα(X)ω。如果 β 是个极限序数,则没有对应的 ψ 函数。

那么,对于类似 ΩΩΩΩΩ3×3 的东西,又要如何处理呢?答案是把下标也看做一个运算,如 ΩΩ 被看做ΩΩ。展开过程中找最右侧的 Ωα 时找的是下标的 Ω 而非整体的 ΩΩ。换句话说,“找最右侧的 Ωα”本身就要求 α 一定小于 Ω

以下是补充的操作规则:

ψ(XΩα+1)[m]=ψ(Xψα(Xψα(Xψα(Xmlayers)))),α 为任意序数,~ 代表 + 或 × 或 ^ 或下标。

ψ(XΩβ)[m]=ψ(XΩβ[m]),如果 β 是极限序数。

这套规则可以一直运用到 ψ(ΩΩΩ),这个序数称为 EBO。如果想要继续前进,就需要新的非递归序数了,它们会给出它们对应的折叠规则。具体则需要参见对应词条。

那么在这里,我们实际上可以说,OCF 本身是一个和增长层级类似的“壳子”,它们接受对应的非递归序数,然后输出大的递归序数。那么,为什么 OCF 没有像增长层级(如 FGH)一样占据 googology 的所有空间呢?有两方面原因。

第一方面,OCF 没有像增长层级一样具有非常明确的转化规则。googology 社区有一个“俗话”——1000 个人有 1001 种 Mahlo OCF。这种共识的缺乏是致命的。

第二方面,对于目前的 googology 爱好者来说,构造非递归序数的难度和构造其他类型序数记号,如 Worm 型记号,相比,在难度上拉不开差距。不像 FGH 加序数记号对传统数阵记号的“降维打击”。而且,googology 爱好者普遍没有很强的数理逻辑或序数分析基础,难以理解和运用学界所构造的大可数序数。

但我还是希望,伴随着 googology 爱好者水平不断提高,有一天 OCF 加大非递归序数会占据 googology 的主流,而 Worm 型记号会像曾经的数阵记号一样被边缘化。如果是这样,那对于 googology 来说,就是不亚于 2014 年的大飞跃发展了。