查看“︁序数坍缩函数”︁的源代码

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

== 教学 ==

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

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

# <math>C_0(x)=\{0,\Omega\}</math>
# <math>C_{n+1}(x)=C_n(x)\cup\{\alpha+\beta,\psi(\gamma)|\alpha,\beta,\gamma\in C_n(x),\gamma <x\}</math>
# <math>C(x)=\bigcup_{n<\omega}C_n(x)</math>
# <math>\psi(x)=\min\{\alpha<\Omega|\alpha\not\in C(x)\}</math>

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

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

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

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

* <math>C_0(0)=\{0,\Omega\}</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(0)=\{0,\Omega,\cdots\}</math>，省略号省掉了大于 <math>\Omega</math> 的序数。

因此 <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>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(2)</math> 中包含了全体小于 <math>\omega^2</math> 的序数和一大堆大于 <math>\Omega</math> 的序数。因此根据定义，<math>\psi(2)=\omega^2</math>。

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

你有没有觉得一步一步按定义走太过于繁琐？下面给出它的 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+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^{\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 函数]]的 <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>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(\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 函数]]依然是孱弱的。为了继续前进，我们需要引入更多的非递归序数。

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

# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|v<\beta<\omega\}</math>
# <math>C_{n+1}^v(x)=\{\alpha+\beta,\psi_{\delta}(\gamma)|\alpha,\beta,\gamma\in C_n^v(x),\gamma<x,\delta<\omega\}</math>
# <math>C^v(x)=\bigcup_{n<\omega}C_n^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>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]] 中是一个非常重要的序数。

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

==== 直观理解与操作规则 ====
让我们从 <math>\psi(0)=1</math> 开始。

BOCF 有这样的性质：

<math>\psi(m+1)=\psi(m)\times\omega</math>，m 是任意序数。

因此，可以得到 <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(\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(\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</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^{\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 的操作规则：

* <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>

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

但如果最右侧是 <math>\Omega</math> 呢？很简单，只需要找到包着它的那一层 <math>\psi</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> 标红的部分。

有的时候最右侧的 <math>\Omega</math> 被藏起来，你需要自己去挖掘出来。比方说 <math>\psi(\Omega^3\times2)</math>，你需要把它写成 <math>\psi(\Omega^3+\Omega^2\times\Omega)</math> 这种形式。

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

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_m</math> 函数，有如下规则：

* <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>

不难发现和 <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(\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 前的 BOCF 的直观理解与操作规则。

==== 枚举 ====
''主条目：[[BOCF VS veblen函数|BOCF VS Veblen 函数]]''

=== MOCF 简介 ===
下面是 MOCF 的数学定义：

# <math>C_0(x)=\{0,1,\omega,\Omega\}</math>
# <math>C_{n+1}(x)=\{\alpha+\beta,\alpha\times\beta,\alpha^\beta,\psi(\gamma)|\alpha,\beta,\gamma\in C_n(x)|\gamma<x\}</math>
# <math>C(x)=\bigcup_{n<\omega}C_n(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 定义：

# <math>C_0^v(x)=\{\alpha|\alpha<\Omega_v\}\cup\{\Omega_{\beta}|\beta<\omega\}</math>
# <math>C_{n+1}^v(x)=\{\alpha+\beta,\alpha\times\beta,\alpha^\beta,\psi_{\delta}(\gamma)|\alpha,\beta,\gamma\in C_n^v(x),\gamma<x,\delta<\omega\}</math>
# <math>C^v(x)=\bigcup_{n<\omega}C_n^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>。此处不再赘述。

MOCF 的 <math>\psi(\Omega_\omega)</math> 也是 BO。

==== 枚举 ====
''主条目：[[BOCF VS MOCF]]''

=== 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>\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_{\alpha+1})[m]=\underbrace{\psi(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\psi_\alpha(X\sim\cdots}_{m~layers}))))</math>，α 为任意序数，~ 代表 + 或 × 或 ^ 或下标。

<math>\psi(X\sim\Omega_\beta)[m]=\psi(X\sim\Omega_{\beta[m]})</math>，如果 β 是极限序数。

这套规则可以一直运用到 <math>\psi(\Omega_{\Omega_{\Omega_{\cdots}}})</math>，这个序数称为 [[EBO]]。如果想要继续前进，就需要新的非递归序数了，它们会给出它们对应的折叠规则。具体则需要参见对应词条。

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

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

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

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

== 定义 ==

=== MOCF ===
令 <math>\Omega_\alpha=\omega_\alpha^{\rm CK},\Omega_0=\omega</math>。

<math>\alpha</math> 的递归共尾度 <math>\mathrm{cf}(\alpha)</math> 定义为 <math>\alpha</math> 的递归的基本列的最小长度。

==== 含第一个非递归序数的 MOCF ====
含第一个非递归序数 <math>\Omega</math> 的 MOCF <math>\psi(\alpha)</math> 定义为利用 <math>0,1,\omega,\Omega</math>，所有的 <math>\psi(\beta)</math> 以及序数加法、乘法、乘方运算，经过任意有限次运算所不能构建的最小序数。特别地，上述定义中的 <math>\beta</math> 满足 <math>\beta<\alpha</math>，且是能够在有限次运算之中通过 <math>0,1,\omega</math> 进行加法、乘法、乘方运算，以及将这些序数放到 MOCF 之中所得到的序数。

以上的定义描述了含 <math>\Omega</math> 的 MOCF 的行为，其集合论定义可以表述如下：

# <math>C^0(\alpha)=\{0,1,\omega,\Omega\}</math>
# <math>C^{n+1}(\alpha)=\{\gamma+\delta,\gamma\cdot\delta,\gamma^\delta,\psi(\eta)|\gamma,\delta,\eta\in C^n(\alpha),\eta<\alpha)\}</math>
# <math>C(\alpha)=\bigcup_{n<\omega}C^n(\alpha)</math>
# <math>\psi(\alpha)=\min\{\beta|\beta\notin C(\alpha)\}</math>

==== 含自然数下标的 MOCF ====
含有 <math>\Omega_n</math> 的 MOCF 标准形式定义为：

# 如果 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，且各 <math>\alpha_i</math> 均为标准形式，则 <math>\alpha=\alpha_1+\alpha_2+\cdots+\alpha_n</math> 也是标准形式。
# 如果 <math>\alpha<\Omega_n,\Omega_n^\beta>\beta</math>，且 <math>\alpha,\beta</math> 均为标准形式，则 <math>\Omega_n^\beta\cdot\alpha</math> 为标准形式。
# 如果 <math>\alpha\in C_n(\alpha)</math>，则 <math>\psi_n(\alpha)</math> 为标准形式。

含有自然数下标的 MOCF <math>\psi(\alpha)</math> 的基本列定义为：

# 若 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，则 <math>\mathrm{cf}(\alpha_1+\alpha_2+\cdots+\alpha_n)=\mathrm{cf}(\alpha_n)</math> 且 <math>(\alpha_1+\alpha_2+\cdots+\alpha_n)[\eta]=\alpha_1+\alpha_2+\cdots+\alpha_n[\eta]</math>
# <math>\mathrm{cf}(\psi_n(0))=\omega</math>，且 <math>\psi_n(0)[0]=\Omega_n,\psi_n(0)[n'+1]=\Omega_n^{\psi_n(0)[n']}</math>
# <math>\mathrm{cf}(\psi_n(\alpha+1))=\omega</math>，且 <math>\psi_n(\alpha+1)[0]=\psi(\alpha),\psi_n(\alpha+1)[n'+1]=\psi_n(\alpha)^{\psi_n(\alpha+1)[n']}</math>
# <math>\mathrm{cf}(\Omega_n)=\Omega_n</math>，且 <math>\Omega_n[\eta]=\eta</math>
# 若 <math>\mathrm{cf}(\alpha)\geqslant\omega</math>，则 <math>\mathrm{cf}(\Omega_n^\alpha)=\mathrm{cf}(\alpha)</math> 且 <math>(\Omega_n^\alpha)[\eta]=\Omega_n^{\alpha[\eta]}</math>
# 若 <math>\mathrm{cf}(\beta)\geqslant\omega</math>，则 <math>\mathrm{cf}(\Omega_n^\alpha\cdot\beta)=\mathrm{cf}(\beta)</math> 且 <math>(\Omega_n^\alpha\cdot\beta)[\eta]=\Omega_n^\alpha\cdot\beta[\eta]</math>
# <math>\mathrm{cf}(\Omega_n^\alpha\cdot(\beta+1))=\mathrm{cf}(\Omega_n^\alpha)</math>，且 <math>\Omega_n^\alpha\cdot(\beta+1)[\eta]=\Omega_n^\alpha\cdot\beta+\Omega^{\alpha[\eta]}</math>
# 若 <math>\mathrm{cf}(\alpha)=\Omega_n,m\leqslant n</math>，则 <math>\mathrm{cf}(\psi_m(\alpha))=\mathrm{cf}(\alpha)</math> 且 <math>\psi_n(\alpha)[\eta]=\psi_n(\alpha[\eta])</math>
# 若 <math>\mathrm{cf}(\alpha)=\Omega_{n+1},m\leqslant n</math>，则 <math>\mathrm{cf}(\psi_m(\alpha))=\omega</math> 且 <math>\psi_m(\alpha)[n']=\psi_m(\alpha[\gamma[n']])</math>，其中 <math>\gamma[0]=0,\gamma[n'+1]=\psi_n(\alpha[\gamma[n']])</math>

含有自然数下标的 MOCF <math>\psi_n(\alpha)</math> 定义为利用所有小于 <math>\Omega_n</math> 的序数、所有自然数下标的 <math>\Omega_m</math>，所有自然数下标的 <math>\psi_m(\beta)</math> 以及序数加法、乘法、乘方运算，经过任意有限次运算所不能构建的最小序数。特别地，上述定义中的 <math>\beta</math> 满足 <math>\beta<\alpha</math>，且是能够在此前的运算之中得到的序数。

以上的定义描述了含自然数下标 的 MOCF 的行为，其集合论定义可以表述如下：

# <math>C_n^0(\alpha)=\{\xi|\xi<\Omega_n\}\cup\{\Omega_{n'}|n'\in\mathbb{N}\}</math>
# <math>C_n^{m+1}(\alpha)=\{\gamma+\delta,\gamma\cdot\delta,\gamma^\delta,\psi_{n'}(\eta)|\gamma,\delta,\eta\in C_n^m(\alpha),n'\in\mathbb{N},\eta<\alpha)\}</math>
# <math>C_n(\alpha)=\bigcup_{m\in\mathbb{N}}C_n^m(\alpha)</math>
# <math>\psi_n(\alpha)=\min\{\beta|\beta\notin C_n(\alpha)\}</math>

==== 含序数下标的 MOCF ====
含有 <math>\Omega_\mu</math> 的 MOCF 标准形式定义为：

# 如果 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，且各 <math>\alpha_i</math> 均为标准形式，则 <math>\alpha=\alpha_1+\alpha_2+\cdots+\alpha_n</math> 也是标准形式。
# 如果 <math>\alpha<\Omega_\mu,\Omega_\mu^\beta>\beta</math>，且 <math>\alpha,\beta,\mu</math> 均为标准形式，则 <math>\Omega_\mu^\beta\cdot\alpha</math> 为标准形式。
# 如果 <math>\alpha\in C_\mu(\alpha)</math>，则 <math>\psi_\mu(\alpha)</math> 为标准形式。

含有序数下标的 MOCF <math>\psi(\alpha)</math> 的基本列定义为：

# 若 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，则 <math>\mathrm{cf}(\alpha_1+\alpha_2+\cdots+\alpha_n)=\mathrm{cf}(\alpha_n)</math> 且 <math>(\alpha_1+\alpha_2+\cdots+\alpha_n)[\eta]=\alpha_1+\alpha_2+\cdots+\alpha_n[\eta]</math>
# <math>\mathrm{cf}(\psi_\nu(0))=\omega</math>，且 <math>\psi_\nu(0)[0]=\Omega_n,\psi_\nu(0)[n+1]=\Omega_\nu^{\psi_\nu(0)[n]}</math>
# <math>\mathrm{cf}(\psi_\nu(\alpha+1))=\omega</math>，且 <math>\psi_\nu(\alpha+1)[0]=\psi(\alpha),\psi_\nu(\alpha+1)[n+1]=\psi_\nu(\alpha)^{\psi_\nu(\alpha+1)[n]}</math>
# <math>\mathrm{cf}(\Omega_{\mu+1})=\Omega_{\mu+1}</math>，且 <math>\Omega_n[\eta]=\eta</math>
# 若 <math>\mathrm{cf}(\alpha)\geqslant\omega</math>，则 <math>\mathrm{cf}(\Omega_\mu^\alpha)=\mathrm{cf}(\alpha)</math> 且 <math>(\Omega_\mu^\alpha)[\eta]=\Omega_\mu^{\alpha[\eta]}</math>
# 若 <math>\mathrm{cf}(\beta)\geqslant\omega</math>，则 <math>\mathrm{cf}(\Omega_\mu^\alpha\cdot\beta)=\mathrm{cf}(\beta)</math> 且 <math>(\Omega_\mu^\alpha\cdot\beta)[\eta]=\Omega_\mu^\alpha\cdot\beta[\eta]</math>
# <math>\mathrm{cf}(\Omega_\mu^\alpha\cdot(\beta+1))=\mathrm{cf}(\Omega_\mu^\alpha)</math>，且 <math>\Omega_\mu^\alpha\cdot(\beta+1)[\eta]=\Omega_\mu^\alpha\cdot\beta+\Omega^{\alpha[\eta]}</math>
# 若 <math>\mathrm{cf}(\alpha)=\Omega_\mu,\mu\leqslant\nu</math>，则 <math>\mathrm{cf}(\psi_\mu(\alpha))=\mathrm{cf}(\alpha)</math> 且 <math>\psi_\nu(\alpha)[\eta]=\psi_\nu(\alpha[\eta])</math>
# 若 <math>\mathrm{cf}(\alpha)=\Omega_{\mu+1},\mu\leqslant\nu</math>，则 <math>\mathrm{cf}(\psi_\mu(\alpha))=\omega</math> 且 <math>\psi_\mu(\alpha)[n]=\psi_\mu(\alpha[\gamma[n]])</math>，其中 <math>\gamma[0]=0,\gamma[n+1]=\psi_\nu(\alpha[\gamma[n]])</math>

含有序数下标的 MOCF <math>\psi_\nu(\alpha)</math> 定义为利用所有小于 <math>\Omega_\nu</math> 的序数、所有自然数下标的 <math>\Omega_\mu</math>，所有自然数下标的 <math>\psi_\mu(\beta)</math> 以及序数加法、乘法、乘方运算，经过任意有限次运算所不能构建的最小序数。特别地，上述定义中的 <math>\beta</math> 满足 <math>\beta<\alpha</math>，且是能够在此前的运算之中得到的序数。

以上的定义描述了含序数下标 的 MOCF 的行为，其集合论定义可以表述如下：

# <math>C_\nu^0(\alpha)=\{\xi|\xi<\Omega_\nu\}\cup\{\Omega_{\mu}|\mu\in\mathbb{N}\}</math>
# <math>C_\nu^{m+1}(\alpha)=\{\gamma+\delta,\gamma\cdot\delta,\gamma^\delta,\psi_\mu(\eta)|\gamma,\delta,\eta\in C_\nu^m(\alpha),\mu\in\mathbb{N},\eta<\alpha)\}</math>
# <math>C_\nu(\alpha)=\bigcup_{m\in\mathbb{N}}C_\nu^m(\alpha)</math>
# <math>\psi_\nu(\alpha)=\min\{\beta|\beta\notin C_\nu(\alpha)\}</math>

=== BOCF ===
含有 <math>\Omega_\mu</math> 的 BOCF 标准形式定义为：

# 如果 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，且各 <math>\alpha_i</math> 均为标准形式，则 <math>\alpha=\alpha_1+\alpha_2+\cdots+\alpha_n</math> 也是标准形式。
# 如果 <math>\mu</math>，则 <math>\Omega_\mu</math> 为标准形式。
# 如果 <math>\alpha\in C_\mu(\alpha)</math>，则 <math>\psi_\mu(\alpha)</math> 为标准形式。

含有序数下标的 BOCF <math>\psi(\alpha)</math> 的基本列定义为：

# 若 <math>\alpha_1\geqslant\alpha_2\geqslant\cdots\geqslant\alpha_n</math>，则 <math>\mathrm{cf}(\alpha_1+\alpha_2+\cdots+\alpha_n)=\mathrm{cf}(\alpha_n)</math> 且 <math>(\alpha_1+\alpha_2+\cdots+\alpha_n)[\eta]=\alpha_1+\alpha_2+\cdots+\alpha_n[\eta]</math>
# <math>\psi(0)=1</math>
# <math>\mathrm{cf}(\psi_{\nu+1}(0))=\mathrm{cf}(\Omega_{\nu+1})</math>，且 <math>\psi_{\nu+1}(0)[\eta]=\eta</math>
# 若 <math>\mathrm{cf}(\nu)\geqslant\omega</math>，则 <math>\mathrm{cf}(\psi_\nu(0))=\mathrm{cf}(\nu)</math>，且 <math>\psi_\nu(0)[\eta]=\psi_{\nu[\eta]}(0)</math>
# <math>\mathrm{cf}(\psi_\nu(\beta+1))=\omega</math>，且 <math>\psi_\nu(\beta+1)[0]=0,\psi_\nu(\beta+1)[n+1]=\psi_\nu(\beta+1)[n]+\psi_\nu(\beta)</math>
# 若 <math>\mathrm{cf}(\beta)\in\{\omega\}\cap\{\Omega_{\mu+1}|\mu<\nu\}</math>，则 <math>\mathrm{cf}(\psi_\nu(\beta))=\mathrm{cf}(\beta)</math>，且 <math>\psi_\nu(\beta)[\eta]=\psi_\nu(\beta[\eta])</math>
# 若 <math>\mathrm{cf}(\alpha)=\Omega_{\mu+1},\mu\geqslant\nu</math>，则 <math>\mathrm{cf}(\psi_\nu(\beta))=\omega</math> 且 <math>\psi_\nu(\beta)[n]=\psi_\nu(\beta[\gamma[n]])</math>，其中 <math>\gamma[0]=\Omega_\mu,\gamma[n+1]=\psi_\mu(\alpha[\gamma[n]])</math>

其集合论定义可以表述如下：

# <math>C_\nu^0(\alpha)=\{\xi|\xi<\Omega_\nu\}</math>
# <math>C_\nu^{m+1}(\alpha)=\{\gamma+\delta,\psi_\mu(\eta)|\gamma,\delta,\eta\in C_\nu^m(\alpha),\mu\in\bold{Ord},\eta<\alpha)\}</math>
# <math>C_\nu(\alpha)=\bigcup_{m\in\mathbb{N}}C_\nu^m(\alpha)</math>
# <math>\psi_\nu(\alpha)=\min\{\beta|\beta\notin C_\nu(\alpha)\}</math>

=== NOCF ===
''主条目：[[NOCF]]''

由于 NOCF 没有完整的定义，这里给出它的理念：

<math>\psi_\alpha(0)=\Omega_\alpha\quad(\Omega_0=1)</math>，<math>\psi_\alpha(\sharp+1)=\psi_\alpha(\sharp)+1</math>；在 OCF 内遇到 <math>\Omega_\alpha</math> 的处理方式与 MOCF 一致。

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