Googology Wiki - 用户贡献 [zh-cn]

传递闭包

2025-09-04T00:10:45Z

Apocalypse：已还原Apocalypse（讨论）的编辑至最后由Tabelog修订的版本

=== 集合的传递闭包 ===
我们把满足这三个条件的唯一传递集合 <math>Y</math> 称作 <math>X</math> 的'''传递闭包（Transitive Closure）'''，记作 <math>\mathcal{TC}(X)</math>：

对任意集合 <math>X</math>，存在唯一集合 <math>Y</math>，满足如下条件
* <math>Y</math> 是[[传递集]]；
* <math>X\sube Y</math>；
* 如果传递集 <math>Z</math> 满足 <math>X\sube Z</math>，则 <math>Y\sube Z</math>。

==== 定理 ====
* '''传递闭包唯一存在'''

证明

使用[[序数#有限序数|自然数]]集上的归纳法，定义集合列 <math>X_0,X_1,X_2,\cdots</math> 满足：
* <math>X_0=X</math>；
* <math>X_{n+1}=X_n\cup(\bigcup X_n)</math>。
这里的 <math>\bigcup X_n</math> 是'''<span id="广义并">广义并</span>'''，定义为 <math>\{x\mid\exist y\in X_n,x\in y\}</math>。这个集合的存在性由[[ZFC公理体系#并集公理|并集公理]]保证。

令 <math>Y=\bigcup\{X_n\mid x\in\N\}</math>，这里又用到了广义并。

下面证明，这样构造出的 <math>Y</math> 满足定理要求。

对任意的 <math>y\in Y</math> 和 <math>x\in y</math>，设 <math>y\in X_n</math>，则 <math>x\in\bigcup X_n\sube X_{n+1}</math>，即 <math>x\in X_{n+1}</math>，所以 <math>x\in Y</math>。所以 <math>Y</math> 是传递集。

显然 <math>X=X_0\sube Y</math>。

设传递集 <math>Z</math> 满足 <math>X\sube Z</math>，即 <math>X_0\sube Z</math>。我们证明：对任意 <math>n\in\N</math>，若 <math>X_n\sube Z</math>，则 <math>X_{n+1}\sube Z</math>。

假设 <math>X_n\sube Z</math>。对任意的 <math>y\in X_n</math> 和 <math>x\in y</math>，有 <math>y\in Z</math>。因为 <math>Z</math> 是传递集，所以 <math>x\in Z</math>。这说明 <math>\bigcup X_n\sube Z</math>。又因为 <math>X_n\sube Z</math>，所以 <math>X_{n+1}=X_n\cup(\bigcup X_n)\sube Z</math>。

因为 <math>X_0\sube Z</math>，且若 <math>X_n\sube Z</math> 则 <math>X_{n+1}\sube Z</math>，所以对任意 <math>n\in\N</math> 都有 <math>X_n\sube Z</math>。所以 <math>Y\sube Z</math>。

这就证明了定理中的存在性。下面证明唯一性。

若 <math>Y_1,Y_2</math> 都满足以上三个条件，那么根据第三个条件，有 <math>Y_1\sube Y_2</math> 且 <math>Y_2\sube Y_1</math>，即 <math>Y_1=Y_2</math>。所以满足以上三个条件的集合唯一。

证毕。

=== 关系的传递闭包 ===
设 <math>\mathcal R_1</math> 是集合 <math>A</math> 上的一个二元关系，如果 <math>A</math> 上的一个二元关系 <math>\mathcal R_2</math> 满足如下条件，就称为 <math>\mathcal R_1</math> 的'''传递闭包'''。

* <math>\mathcal R_2</math> 有传递性。
* <math>\mathcal R_1\sube\mathcal R_2</math>。
* 如果 <math>A</math> 上的一个二元传递关系 <math>\mathcal R_3</math> 满足 <math>\mathcal R_1\sube\mathcal R_3</math>，则 <math>\mathcal R_2\sube\mathcal R_3</math>。
[[分类:集合论相关]]

首页

2025-09-04T00:10:41Z

Apocalypse：已还原Apocalypse（讨论）的编辑至最后由Tabelog修订的版本

<div class="googology-home">
<h1 class="main-title"><span class="mw-headline" id="Googology_Wiki">Googology Wiki</span></h1>
<div class="tagline">Mapping the Universe of Monumental Numbers.</div>

<div class="fixed-grid">
<div class="fixed-btn">
[[:Category:记号|<span class="btn-text blue">记号</span>]]
</div>
<div class="fixed-btn">
[[:Category:分析|<span class="btn-text blue">分析</span>]]
</div>
<div class="fixed-btn">
[[:Category:入门|<span class="btn-text blue">入门</span>]]
</div>
<div class="fixed-btn">
[[:序数表|<span class="btn-text blue">序数表</span>]]
</div>
<div class="fixed-btn">
[[:Category:重要概念|<span class="btn-text blue">重要概念</span>]]</span>
</div>
<div class="fixed-btn">
[[:Googology_梗百科|<span class="btn-text blue">梗百科</span>]]
</div>
<div class="fixed-btn">
[[:大数简史|<span class="btn-text blue">大数简史</span>]]
</div>
<div class="fixed-btn">
[[:Googology_社区|<span class="btn-text blue">社区</span>]]
</div>
<div class="fixed-btn">
[[:记号展开器|<span class="btn-text blue">展开器</span>]]
</div>
<div class="fixed-btn">
[[:Category:集合论相关|<span class="btn-text blue">集合论相关</span>]]
</div>
</div>


<div class="wiki-stats-container">
<div class="home-card">
<h2 style="margin-top: 0">数据统计</h2>
<p>Googology Wiki 欢迎你的编辑！</p>

<div class="template-statsbar">
<div class="template-statsbar__item">
<div class="template-statsbar__label">总条目数</div>
<div class="template-statsbar__data" id="totalArticles">loading...</div>
</div>

<div class="template-statsbar__item">
<div class="template-statsbar__label">总编辑数</div>
<div class="template-statsbar__data" id="totalEdits">loading...</div>
</div>

<div class="template-statsbar__item">
<div class="template-statsbar__label">注册用户数</div>
<div class="template-statsbar__data" id="totalUsers">loading...</div>
</div>

</div>
</div>
</div>
</div>

首页

2025-09-04T00:10:16Z

Apocalypse：已还原Tabelog（讨论）的编辑至最后由Phyrion修订的版本

<div class="googology-home">
<h1 class="main-title"><span class="mw-headline" id="Googology_Wiki">Googology Wiki</span></h1>
<div class="tagline">Mapping the Universe of Monumental Numbers.</div>

<div class="fixed-grid">
<div class="fixed-btn">
[[:Category:记号|<span class="btn-text blue">记号</span>]]
</div>
<div class="fixed-btn">
[[:Category:分析|<span class="btn-text blue">分析</span>]]
</div>
<div class="fixed-btn">
[[:Category:入门|<span class="btn-text blue">入门</span>]]
</div>
<div class="fixed-btn">
[[:序数表|<span class="btn-text blue">序数表</span>]]
</div>
<div class="fixed-btn">
[[:Category:重要概念|<span class="btn-text blue">重要概念</span>]]</span>
</div>
<div class="fixed-btn">
[[:Googology_梗百科|<span class="btn-text blue">梗百科</span>]]
</div>
<div class="fixed-btn">
[[:大数简史|<span class="btn-text blue">大数简史</span>]]
</div>
<div class="fixed-btn">
[[:Googology_社区|<span class="btn-text blue">社区</span>]]
</div>
<div class="fixed-btn">
[[:记号展开器|<span class="btn-text blue">展开器</span>]]
</div>
<div class="fixed-btn">
[[:Category:证明|<span class="btn-text blue">证明</span>]]
</div>
</div>


<div class="wiki-stats-container">
<div class="home-card">
<h2 style="margin-top: 0">数据统计</h2>
<p>Googology Wiki 欢迎你的编辑！</p>

<div class="template-statsbar">
<div class="template-statsbar__item">
<div class="template-statsbar__label">总条目数</div>
<div class="template-statsbar__data" id="totalArticles">loading...</div>
</div>

<div class="template-statsbar__item">
<div class="template-statsbar__label">总编辑数</div>
<div class="template-statsbar__data" id="totalEdits">loading...</div>
</div>

<div class="template-statsbar__item">
<div class="template-statsbar__label">注册用户数</div>
<div class="template-statsbar__data" id="totalUsers">loading...</div>
</div>

</div>
</div>
</div>
</div>

传递闭包

2025-09-04T00:09:57Z

Apocalypse：已还原Tabelog（讨论）的编辑至最后由QWQ-bili修订的版本

== 集合的传递闭包 ==

我们把满足这三个条件的唯一传递集合 <math>Y</math> 称作 <math>X</math> 的'''传递闭包（Transitive Closure）'''，记作 <math>\mathcal{TC}(X)</math>：

对任意集合 <math>X</math>，存在唯一集合 <math>Y</math>，满足如下条件
* <math>Y</math> 是[[传递集]]；
* <math>X\sube Y</math>；
* 如果传递集 <math>Z</math> 满足 <math>X\sube Z</math>，则 <math>Y\sube Z</math>。

=== 定理 ===

* '''传递闭包唯一存在'''

证明

使用[[序数#有限序数|自然数]]集上的归纳法，定义集合列 <math>X_0,X_1,X_2,\cdots</math> 满足：
* <math>X_0=X</math>；
* <math>X_{n+1}=X_n\cup(\bigcup X_n)</math>。
这里的 <math>\bigcup X_n</math> 是'''<span id="广义并">广义并</span>'''，定义为 <math>\{x\mid\exist y\in X_n,x\in y\}</math>。这个集合的存在性由[[ZFC公理体系#并集公理|并集公理]]保证。

令 <math>Y=\bigcup\{X_n\mid x\in\N\}</math>，这里又用到了广义并。

下面证明，这样构造出的 <math>Y</math> 满足定理要求。

对任意的 <math>y\in Y</math> 和 <math>x\in y</math>，设 <math>y\in X_n</math>，则 <math>x\in\bigcup X_n\sube X_{n+1}</math>，即 <math>x\in X_{n+1}</math>，所以 <math>x\in Y</math>。所以 <math>Y</math> 是传递集。

显然 <math>X=X_0\sube Y</math>。

设传递集 <math>Z</math> 满足 <math>X\sube Z</math>，即 <math>X_0\sube Z</math>。我们证明：对任意 <math>n\in\N</math>，若 <math>X_n\sube Z</math>，则 <math>X_{n+1}\sube Z</math>。

假设 <math>X_n\sube Z</math>。对任意的 <math>y\in X_n</math> 和 <math>x\in y</math>，有 <math>y\in Z</math>。因为 <math>Z</math> 是传递集，所以 <math>x\in Z</math>。这说明 <math>\bigcup X_n\sube Z</math>。又因为 <math>X_n\sube Z</math>，所以 <math>X_{n+1}=X_n\cup(\bigcup X_n)\sube Z</math>。

因为 <math>X_0\sube Z</math>，且若 <math>X_n\sube Z</math> 则 <math>X_{n+1}\sube Z</math>，所以对任意 <math>n\in\N</math> 都有 <math>X_n\sube Z</math>。所以 <math>Y\sube Z</math>。

这就证明了定理中的存在性。下面证明唯一性。

若 <math>Y_1,Y_2</math> 都满足以上三个条件，那么根据第三个条件，有 <math>Y_1\sube Y_2</math> 且 <math>Y_2\sube Y_1</math>，即 <math>Y_1=Y_2</math>。所以满足以上三个条件的集合唯一。

证毕。

== 关系的传递闭包 ==

设 <math>\mathcal R_1</math> 是集合 <math>A</math> 上的一个二元关系，如果 <math>A</math> 上的一个二元关系 <math>\mathcal R_2</math> 满足如下条件，就称为 <math>\mathcal R_1</math> 的'''传递闭包'''。

* <math>\mathcal R_2</math> 有传递性。
* <math>\mathcal R_1\sube\mathcal R_2</math>。
* 如果 <math>A</math> 上的一个二元传递关系 <math>\mathcal R_3</math> 满足 <math>\mathcal R_1\sube\mathcal R_3</math>，则 <math>\mathcal R_2\sube\mathcal R_3</math>。

Fake Fake Fake Zeta

2025-08-22T04:36:52Z

Apocalypse：已还原Z（讨论）的编辑至最后由Ankdnjj修订的版本

'''Fake Fake Fake Z(FFFZ)'''，是由 yahtzee 于 2022 年提出，后续由国内的大数研究者夏夜星空完善的'''前沿记号'''。

== 定义 ==
'''注意：FFFZ 的定义尚未完全确定，且有较为频繁的更改(大部分是修改一些小问题,比如简化、修错别字)。这里叙述最新一版(2025.7.26)的定义。'''

'''注意：部分概念的定义被修改为了等价版本。这些修改与原始文本之间是逻辑意义上的等价。'''

=== 主体规则 ===
FFFZ的合法表达式形如<math>\psi_Z[\#](n)</math>，极限基本列为<math>\{\psi_Z(0),\psi_Z(\psi_Z(0)),\psi_Z(\psi_Z(\psi_Z(0))),\cdots\}</math>。

# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>
# 如果<math>[\#,m,n]</math>存在，<math>\psi_Z[\#,m](n)[s]=f^s(n)</math>，其中<math>f(x)=\psi_Z[\#,m,n](x)</math>
# 如果<math>[\#,m,n]</math>不存在，<math>\psi_Z[\#,m](n)[s]=\psi_Z[\#,m](n[t+s])</math>。其中<math>t</math>定义如下：
* 如果<math>m\geq{n}</math>，那么<math>t=0</math>。
* 如果<math>m<n</math>，那么<math>t</math>是满足<math>n[t]\geq{m}</math>的最小非负整数。

=== 化简规则 ===
* <math>\psi_Z[\#,m](n)=\psi_Z[\#](n)</math>，<math>m>n</math>
* <math>\psi_Z[](n)=\psi_Z(n)</math>

为了判定<math>[\#]</math>的存在性，定义以下概念：

=== 名称解释 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，记它的末项为<math>Endseq(\#)=\alpha_m</math>。

对于序数<math>\alpha</math>，写出它的Cantor范式<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>。称<math>\omega^{\alpha_n}</math>为<math>\alpha</math>的末项。

如果<math>\alpha</math>等于它的末项，称<math>\alpha</math>为'''简单序数'''，否则为'''复合序数'''。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#](n)</math>：
# 如果<math>n</math>是后继序数，称<math>\alpha</math>是<math>+</math>型极限，或0级极限，等级为0。
# 如果<math>[\#,n]</math>不存在，称<math>\alpha</math>是<math>\omega</math>型极限，或1级极限，等级为1。
# 如果<math>[\#,n]</math>存在，称<math>\alpha</math>是<math>\varepsilon</math>型极限，或2级极限，等级为2。

对于两个非零简单序数<math>\alpha</math>和<math>\beta</math>：
# 如果<math>\alpha</math>的等级大于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>高等。
# 如果<math>\alpha</math>的等级等于<math>\beta</math>的等级，称<math>\alpha</math>和<math>\beta</math>同等。
# 如果<math>\alpha</math>的等级小于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>低等。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#,m](n)</math>：
# 如果<math>[\#,m,n]</math>不存在，则<math>\alpha</math>的根为<math>n</math>。
# 如果<math>[\#,m,n]</math>存在，则<math>\alpha</math>的根为<math>m</math>。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z(n)</math>，则它的根为<math>n</math>。

对于序数<math>\alpha</math>：
# 如果它是复合序数，它形如<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>，则每个<math>\omega^{\alpha_k}</math>被它直接包含。
# 如果它是非零简单序数，它形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>，则每个<math>\alpha_k</math>均被它直接包含，<math>n</math>也被它直接包含。
#如果它是0，没有任何序数被它直接包含。

<math>\alpha</math>直接包含<math>\beta</math>，记为<math>dInc(\beta,\alpha)</math>。

接下来是几个较为复杂的定义。

==== 末项，核与层数 ====
对于非零序数<math>\alpha</math>和简单序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的末项是以下两个序数<math>u</math>中较大者：
* <math>u</math>是满足“<math>u<s</math>，且存在序数<math>v</math>使<math>v+u=\alpha</math>”的最大序数。
* <math>u</math>是满足“<math>u</math>是简单序数且存在序数<math>w</math>，使得<math>\alpha=u\times{w}</math>”的最大序数。
* 如果上述两个规则中某条规则没有任何序数<math>u</math>能够满足，那么忽视那条规则。

<math>\alpha</math>关于<math>s</math>的末项记为<math>End(\alpha,s)</math>。特别地，<math>\alpha</math>关于<math>0</math>的末项与上文定义的末项等价，记为<math>End(\alpha)</math>。

对于序数<math>\alpha</math>，序数<math>s</math>，不小于-1的整数<math>k</math>，<math>\alpha</math>关于<math>s</math>的<math>k</math>层核，记为<math>Ker(\alpha,s,k)</math>，定义如下：
* <math>Ker(\alpha,s,-1)=\alpha</math>
* <math>Ker(0,s,k)=0</math>

以下假设<math>\alpha</math>非零，<math>k</math>是非负整数：
* <math>Ker(\alpha,s,k)=Ker(End(\alpha),End(s),k)</math>

以下假设<math>\alpha</math>和<math>s</math>都是非零简单序数，<math>k</math>是非负整数，<math>\alpha</math>形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>：
* <math>Ker(\alpha,s,0)=\psi_Z[End(\alpha_1,s),End(\alpha_2,s),\cdots,End(\alpha_m,s)](End(n,s))</math>
* <math>Ker(\alpha,s,k+1)=Ker(\psi_Z[Ker(\alpha_1,s,k),Ker(\alpha_2,s,k),\cdots,Ker(\alpha_m,s,k)](Ker(n,s,k)),s,0)</math>

对于序数<math>\alpha</math>，其层数是一个非负整数，记为<math>Lev(\alpha)</math>，定义如下：

* <math>Lev(0)=0</math>
* <math>Lev(\alpha)=max\{Lev(\beta)\mid{dInc(\beta,\alpha)}\}+1</math>

层数可以简单的理解为“ψZ嵌套的次数”

对于非零序数<math>\alpha</math>，序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的核记为<math>Ker(\alpha,s)</math>，它定义为<math>Ker(\alpha,s)=Ker(\alpha,s,Lev(\alpha))</math>。

特别地，<math>\alpha</math>的核记为<math>Ker(\alpha)</math>，它定义为<math>Ker(\alpha)=Ker(\alpha,0,Lev(\alpha))</math>。

=== 双元兼容 ===
对于序数<math>\alpha=\psi_Z[\#](n)</math>和<math>\beta=\psi_Z[\&](m)</math>，依次进行以下判定：
# 如果<math>\alpha>\beta</math>，则<math>[\alpha,\beta]</math>存在。
# 如果<math>\alpha</math>和<math>\beta</math>中至少有一个复合序数，则<math>[\alpha,\beta]</math>存在当且仅当<math>[End(\alpha),End(\beta)]</math>存在。
# 如果<math>\alpha=0</math>，则<math>[\alpha,\beta]</math>不存在。
# 当<math>\#=\&</math>时，<math>[\alpha,\beta]</math>存在当且仅当<math>[n,m]</math>存在；否则，如果存在序列<math>\%</math>使得<math>End(Endseq(\%))</math>与<math>End(Endseq(\#))</math>，<math>End(Endseq(\&))</math>之一相等，且存在序数<math>x</math>和序数<math>y</math>使得<math>\alpha=\psi_Z[\%](x)</math>且<math>\beta=\psi_Z[\%](y)</math>，则若<math>[x,y]</math>存在那么<math>[\alpha,\beta]</math>存在
# 如果<math>\beta\geq\psi_Z[\alpha](\alpha)</math>，则<math>[\alpha,\beta]</math>存在当且仅当<math>[\alpha,\beta</math>的根<math>]</math>存在；否则，如果存在简单序数<math>s</math>和不小于-1的整数<math>k</math>，使得<math>Ker(\beta,s,k)\geq\psi_Z[Ker(\alpha,s,k)](Ker(\alpha,s,k))</math>且不存在非零序数<math>x</math>和序列<math>\%</math>使得<math>Ker(\beta,s,k)=\psi_Z[Ker(\alpha,s,k)\times\omega,\%](Ker(\alpha,s,k)\times{x})</math>，则当<math>[\alpha,\beta</math>的根<math>]</math>存在时<math>[\alpha,\beta]</math>存在
# 如果存在两个序数<math>A</math>，<math>B</math>，<math>Ker(A)=Ker(\alpha)</math>，<math>Ker(B)=Ker(\beta)</math>，<math>A</math>属于<math>B</math>基本列，且<math>\alpha</math>比<math>\beta</math>高等，则<math>[\alpha,\beta]</math>存在
# 如果通过上述规则均无法说明<math>[\alpha,\beta]</math>存在，则<math>[\alpha,\beta]</math>不存在

=== 多元兼容 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，如果任取满足<math>k>j</math>的<math>\alpha=\alpha_j</math>，<math>\beta=\alpha_k</math>都有'''以下两个条件至少成立一个'''，则<math>[\#]</math>存在。

条件I：以下两个条件至少成立一个：
# <math>[\alpha,\beta]</math>存在
# <math>k<m</math>且存在满足<math>k>l</math>的<math>\gamma=\alpha_l</math>，使得<math>[\gamma,\beta]</math>不存在

条件II：对于任何满足<math>k<l</math>的<math>\gamma=\alpha_l</math>，存在简单序数<math>s</math>，不小于-1的整数<math>n</math>，使得以下两个条件同时成立：
# <math>[\beta,\gamma]</math>存在，且<math>Ker(\alpha,s,n)>Ker(\beta,s,n)</math>
#

''(好吧还没写完(因为看不懂)。除了这条规则(平移转移)，特殊规则以及各种优先级，还要补不少定义域限制，比如“m为序数或空”之类)''

== 直观解释 ==
FFFZ的前几条规则是
# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>

类似于BOCF的规则。为了提升强度，我们需要引入“兼容”的概念。

“兼容”就是中括号里的东西(有时也叫“伪链”，伪即Fake)，通过类似于“挡刀”的方式提升强度。举个例子：对<math>\psi_Z(n)</math>取极限，得到的并不是<math>\psi_Z(\omega)</math>，而是<math>\psi_Z[\omega](\omega)</math>，中括号内出现了挡刀的<math>\omega</math>。只有达到<math>\alpha\to\psi_Z[\omega](\alpha)</math>的第一个不动点时，才能得到<math>\psi_Z(\omega)</math>。

当然，我们并不局限于只把一个序数放进兼容里。兼容里可以有多个序数，举个例子：对<math>\psi_Z[\omega^2](\omega^2+n)</math>取极限，得到的并不是<math>\psi_Z[\omega^2](\omega^2+\omega)</math>，而是<math>\psi_Z[\omega^2,\omega^2+\omega](\omega^2+\omega)</math>。

从提升强度的角度考虑，我们当然希望设计一套规则，允许更多的兼容，从而最大限度地提升强度。但是，这样的规则并不是总是可行——考虑这样的规则：“任意一系列极限序数可以兼容”，那么我们有

<math>\psi_Z(\omega)\to\psi_Z[\omega](\psi_Z[\omega](\omega))\to\psi_Z[\omega](\psi_Z[\omega](2))\to\psi_Z[\omega](\omega\times{2})\to\psi_Z[\omega,\omega\times{2}](\psi_Z[\omega,\omega\times{2}](\omega\times{2}))\to\psi_Z[\omega,\omega\times{2}](\omega\times{3})\to\cdots</math>

无穷降链。

造成这种结果的原因在于，<math>[\omega,\omega\times{2},\omega\times{3},\cdots]</math>这些序数可以无限地兼容下去，形成'''无限兼容链'''。所以，我们希望的规则应该满足以下两个条件：

1. 允许兼容存在，以提升强度。

2. 不允许某些兼容存在，以避免无限兼容链。

由于实际分析和构造的需要，我们还有第三个条件：

3. 允许某些关键节点的特殊兼容存在。

基于上述的理念，作者给出了上文提到的那一系列规则。

''(未完待续。主要是补充一些概念的直观理解，比如“末项”之类的)''

== 一些展开 ==
(1)<math>\psi_Z(\omega)[2]</math>

注意到<math>[ ,\omega]</math>等价于<math>[\omega]</math>,存在,故原式=<math>\psi_Z[\omega](\psi_Z[\omega](\omega))</math>. 这印证了前文里伪链存在的必要.

(2)<math>\psi_Z[\omega](\omega\times 2)</math>[2]

让我们检验一下<math>[\omega,\omega\times 2]</math>是否存在.

<math>\omega</math>的末项为<math>\omega</math>,<math>\omega\times 2</math>的末项为<math>\omega</math>. 化简完后为<math>[\omega,\omega]</math>.

第一条:<math>\omega\leq\omega</math>，不行

第二条:<math>\omega</math>为简单序数，不行

第三条:<math>\omega\neq0</math>，不行

第四条:[n,m]=[1,1]，这是什么？

第五条:<math>\omega<\psi_Z[\omega](\omega)</math>,后面的第一个条件不成立,还不行

第六条:<math>\omega
\omega</math>同等,仍然不行

故<math>[\omega,\omega\times 2]</math>不存在,<math>\psi_Z[\omega](\omega\times2)[2]=\psi_Z[\omega](\omega[2])=\psi_Z[\omega](\omega+2).</math>这样避免了上文的无穷降链.

本质上讲,展开一个fffz重点在于判断伪链. 故(3)以后均是这类例子.

(3)<math>[\omega^2,\omega^2+\omega]</math>是否存在?

<math>\omega^2+\omega</math>的末项为<math>\omega</math>,又<math>\omega^2>\omega</math>，存在.

== 衍生版本 ==
上文介绍的版本称为<math>\rm{Strong}</math>版本。除此之外，还有<math>\rm{Actual}</math>版本和<math>\rm{Weak}</math>版本，各版本区别如下：

=== <math>\rm{Actual}</math>版本 ===
1.除双元兼容第6条外，所有核都必须是关于<math>\omega</math>的
2.对于能合法而不必标准的写成“<math>\psi_Z</math>[#](X+n)，其中X的末项等于<math>\omega</math>，n是正整数，#是任意序列(可以为空)”的形式的序数A，需遵守下列要求：(k可取全体小于<math>\omega</math>的序数)
(1).当A处在[]中时，强制固定A关于<math>\omega</math>的k层核为A关于<math>\omega</math>的核(该核无视其它要求另算)
(2).除(1)之外，强制固定A关于<math>\omega</math>的k层核为A本身

=== <math>\rm{Weak}</math>版本 ===
1.双元兼容第5条失效
2.所有核都必须是-1层的

== 分析 ==
{| class="wikitable"
|+fffz vs BOCF vs BMS
!Fake Fake Fake Zeta
!MOCF
!BMS
|-
|<math>\psi_Z(0)</math>
|1
|<math>(0)</math>
|-
|<math>\psi_Z(1)</math>
|<math>\omega</math>
|<math>(0)(1)</math>
|-
|<math>\psi_Z(2)</math>
|<math>\omega^2</math>
|<math>(0)(1)(1)</math>
|-
|<math>\psi_Z[\omega](\omega)</math>
|<math>\omega^\omega</math>
|<math>(0)(1)(2)</math>
|-
|<math>{\psi_Z}[\omega](\omega+1)</math>
|<math>\omega^{\omega+1}</math>
|<math>(0)(1)(2)(1)</math>
|-
|<math>\psi_Z[\omega](\omega^2)</math>
|<math>\omega^{\omega^2}</math>
|<math>(0)(1)(2)(2)</math>
|-
|<math>\psi_Z[\omega](\psi_Z[\omega](\omega))</math>
|<math>\omega^{\omega^{\omega}}</math>
|<math>(0)(1)(2)(3)</math>
|-
|<math>\psi_Z[\omega](\psi_Z[\omega](\psi_Z[\omega](\omega)))</math>
|<math>\omega^{\omega^{\omega^{\omega}}}</math>
|<math>(0)(1)(2)(3)(4)</math>
|-
|<math>\psi_Z(\omega)</math>
|<math>\psi(0)</math>
|<math>(0,0)(1,1)</math>
|}
[[分类:记号]]

记号类条目编写指南

2025-08-19T20:32:49Z

Apocalypse：

这里是一些编写(序数)记号类条目时的注意事项。一些在[[条目编写指南]]已经提及的部分可能不会重复提及。

在编写记号类条目前，请确保：
* 你'''确实'''会这个记号。
* 最好不要从诸如Word文档的地方直接复制内容，可能出现格式错误。
* 你会用LaTeX写公式。如果你不会，请自行学习，或者等待其它编辑者修改。

== 记号介绍 ==
在条目的开始，你应当写一些关于记号的总结性介绍，一般包括这些内容(或者其中的一部分)：

* 记号的别称，作者，版本；
* 记号的强度；
* 相关的记号。

== 定义 ==
这是记号类条目的核心内容。定义一般包括这些内容：

* 标准表达式的形式
* 与表达式相关的临时定义
* 展开规则(有时附带举例)

在编写定义时，需要注意以下几点：

# '''请尽可能不要夹杂个人观点'''。不要出现类似“xxx是很容易理解的”的内容。
# '''如果需要写解释性内容，请确保这个解释是真的必要的'''。不要在非常简单的地方写解释。
# '''编写时，请不要对记号的定义做实质性改动'''。
# 在上一条的基础上，'''如果你确信你编写的内容与原本记号定义没有实质区别，可以(但一般不建议)改动'''。如果改动幅度太大，你编写的部分'''可能被重写'''。
# 为了良好的观感，'''如果原定义有大量文字，请尝试使用其他内容替代'''。你可以使用临时定义的函数，或者重述定义。尽量不要出现定义是“整页的文字，没几个公式”的情况。
# '''介绍定义时，编写的逻辑顺序应当清晰'''。如果一个定义依赖于另一个定义，介绍时请先介绍后者。
# '''如果要选择展开例子，请选择合理的例子'''。一个(或多个)合理的例子应当比较简单，并且用上大部分的临时定义和规则。

== 枚举 ==
这个部分不是必要的，但请尽可能编写。枚举一般包括这些内容：

* 和强度类似的记号的粗略比对分析。

一般来说，记号个数是1~2个，分析节点数小于40个。

对于比较重要的记号，可以引用一个(它的分析)页面。
[[分类:入门]]

记号类条目编写指南

2025-08-19T20:32:00Z

Apocalypse：创建页面，内容为“这里是一些编写(序数)记号类条目时的注意事项。一些在条目编写指南已经提及的部分可能不会重复提及。在编写记号类条目前，请确保： * 你'''确实'''会这个记号。 * 最好不要从诸如Word文档的地方直接复制内容，可能出现格式错误。 * 你会用LaTeX写公式。如果你不会，请自行学习，或者等待其它编辑者修改。 == 记号介绍 == 在条目的开始，你应…”

ΩSSO

2025-08-18T16:37:59Z

Apocalypse：

ΩSSO（Ω Sequence System Ordinal），又名 WSSO，是常规 [[TBMS]] 的极限。因为该序数第一个是 α→α 行 [[Bashicu矩阵|BMS]] 的不动点而得名。
{| class="wikitable"
![[序数记号]]
!表达式
|-
|[[投影序数|向上投影]]
|<math>\psi(\psi_H(\varphi(H,1)))</math>
|-
|[[BTBMS]]
|<math>(0)(1^{(2,1)})</math>
|-
|[[Y序列|1-Y]]
|<math>1,3,4,2,5,8,10</math>
|-
|[[变种去提升 Y 序列#IY|I 1-Y(w\o 1342575)]]
|<math>1,3,5,6,2,5,10,12</math>
|-
|[[变种去提升 Y 序列#IY|I 1-Y(w\o 1343)]]
|<math>1,3,4,7,10,12</math>
|-
|[[变种去提升 Y 序列#IIIY|III 1-Y]]
|<math>1,3,7,8,11,12,20</math>
|-
|[[Mountain Notation]]
|<math>()(,,1)(,2)(,1)(,4,,4)(,5,,4)(,6,4)</math>
|-
|[[MMS]]
|<math>(0)(1,1)(2)(1)(2,1,1)(3,1,1)(4,1)</math>
|-
|[[DBMS]]
|<math>(0)(1,,1)(2)(1)(2,1,,1)(3,1,,1)(4,1)</math>
|-
|[[Fake Fake Fake Zeta]]
|<math>\psi_\Zeta[\varepsilon_\omega,\varepsilon_\omega\times\omega,\varepsilon_\omega\times(\omega+1)](1-Y(1,3,4))</math>
|}

=== 性质 ===
极限在此处的记号：[[TBMS]]

ΩSSO 是第一个 α→α 行 BMS 的不动点。
[[分类:序数]]

序数

2025-08-18T16:30:19Z

Apocalypse：/* 形式化定义 */

'''序数'''是自然数的推广。

=== 直观理解 ===
[[文件:Omega4.jpg|缩略图|仅供参考]]
顾名思义，序数是用来排序的号码。最小的序数是 0，因而我们从 0 开始排序。这只是一个很简单的排序，还没有超过自然数的范畴。

现在考虑对这个集合 <math>\{ 1/2,3/4,7/8,\ldots \} \cup \{1\}</math>，按照＜来排序：
{| class="wikitable"
|+
!号码
!元素
|-
|1/2
|0
|-
|3/4
|1
|-
|7/8
|2
|-
|……
|……
|-
|1
|？
|}
注意到当我们为 1/2,3/4,7/8,…… 这些元素排序时，已经用尽了全部的自然数。但我们又要为 1 编号。1 大于前面的所有元素，因此，1 的号码需要是一个大于全体自然数的东西。它依然是序数（因为我们定义序数就是为了处理这种情况），我们给它命名为 ω。

想象一下我们在此基础上又要给 <math>\{3/2,7/4,15/8,\ldots\}\cup\{2\}</math> 编号。因此我们还需要越来越多的大于ω的序数。随着“编号游戏”的对象愈发复杂，我们所需要的序数也愈发庞大，复杂，单纯靠直观理解已经难以为继，因此我们需要看以下的内容。

=== 数学定义 ===
序数是在∈序上[[良序]]的传递集（传递集即满足每个元素都是自身的子集）。如：

<math>0=\varnothing=\{\}</math>

<math>1=\{ 0\}</math>

<math>2=\{0,1\}</math>

<math>3=\{0,1,2\}</math>

<math>1048576=\{0,1,2,3,...,1048575\}</math>

==== 序数的后继 ====
序数 <math>\alpha</math> 的'''后继'''被定义为 <math>\alpha+1=\alpha\cup \{\alpha\}</math>。它也是所有'''序数运算'''的基础。

如 <math>2+1=2\cup\{2\}=\{0,1\}\cup\{2\}=\{0,1,2\}=3</math>，<math>n+1=n\cup\{n\}=\{0,1,2,3,...,n\}</math>。

==== 有限序数与超限序数 ====
所有自然数都是'''<span id="有限序数">有限序数</span>'''。

大于任意有限序数的序数称作'''<span id="超限序数">超限序数</span>'''（或无限序数）。

==== 极限序数 ====
不是 0 且'''不是任何序数的后继'''的序数被称为'''极限序数'''。（0 有时也被视为极限序数）

即序数 <math>\lambda</math> 是极限序数要满足“不存在某个序数 <math>\alpha</math> 使得 <math>\lambda=\alpha +1</math>”。

如果 <math>\lambda</math> 是极限序数，那么 <math>\lambda=\sup\{\alpha|\alpha < \lambda\}</math>。

<math>\omega</math> 被定义为全体自然数的集合，<math>\omega=\mathbb{N}=\{0,1,2,3,...\}</math> 既是第一个超限序数，也是第一个极限序数。

==== 基本列 ====
如果序数 <math>\alpha</math> 是一个极限序数，则它的基本列 <math>\langle \alpha[n] \rangle </math> 是一个递增的序数列，并且满足其上确界为 <math>\alpha</math>。即 <math>\alpha={\rm sup}\{\alpha[n]|n\in \mathbb{N}\}={\rm sup}\{\alpha[0],\alpha[1],\alpha[2],...\}</math>。

注意到一个极限序数具有多种基本列。因此为了方便运用和理解，我们需要一套标准基本列系统来给极限序数一个唯一的基本列。

很遗憾的是，不存在一个通用的基本列系统来为所有序数指定标准基本列。因此，我们只能借助[[序数记号]]来为它极限之下的极限序数指定标准基本列。

==== 递归序数与非递归序数 ====

===== 递归序数 =====
一个序数 <math>\alpha</math> 被称为递归序数，当且仅当存在一个图灵机（或等效的可计算函数，或图灵完备的计算机语言），它能计算出一个良序关系 <math>\prec</math>，使得这个良序关系的序型与 <math>\alpha</math> 同构。

直观来讲，递归序数都是可以“自下而上”得到的序数。

所有递归序数的集合也是一个序数，记为 <math>\omega_1^{\rm CK}</math>（又作 <math>\Omega</math>，[[CKO]]）

<math>\omega_1^{\rm CK}=\{0,1,...,\omega,...,\omega^2,...,\omega^\omega,...,\varepsilon_0,...,\varphi(1,0,0),...,\psi(\Omega_{\omega}),...\}</math>

由于图灵机的总数是可数无穷多的，因此 <math>\Omega</math> 依然是一个可数序数。

===== 非递归序数 =====
不是递归序数的序数被称为非递归序数。

最小的非递归序数就是所有递归序数的集合 <math>\omega_1^{\rm CK}</math>。

==== 可数序数与不可数序数 ====
如果一个序数与有限基数或 <math>\aleph_0</math> 等势，则它是可数序数。如 <math>0,1,2,\omega,\varepsilon_0,\psi(\Omega_{\omega}),Y(1,3),\Omega,I,\psi_{\alpha}(\alpha_{\omega}),\omega_1^L</math> 等等都是可数序数。

不是可数序数的序数是不可数序数，如 <math>\omega_1</math>。

=== 序数的运算 ===

==== 序数加法 ====
<math>\alpha+0=\alpha</math>

<math>\alpha+(\beta+1)=(\alpha+\beta)+1</math>

<math>\alpha+\beta=\bigcup_{\gamma <\beta}(\alpha +\gamma)</math>，如果 <math>\beta</math> 是极限序数。

序数加法不具有交换律，但具有结合律。即

<math>\alpha+\beta\ne\beta+\alpha,(\alpha+\beta)+\gamma=\alpha+(\beta+\gamma)</math>

例：<math>1+\omega=\bigcup_{\gamma <\omega}(1 +\gamma)=\{1+0,1+1,1+2,...\}={\rm sup}\{1,2,3,...\}=\omega\ne \omega+1</math>

==== 序数乘法 ====
<math>\alpha\times0=0</math>

<math>\alpha\times(\beta+1)=(\alpha\times\beta)+\alpha</math>

<math>\alpha\times\beta=\bigcup_{\gamma <\beta}(\alpha \times\gamma)</math>，如果 <math>\beta</math> 是极限序数。

序数乘法不具有交换律和右分配律，但具有结合律和左分配律。即

<math>1.\alpha\times\beta\ne\beta\times\alpha,(\alpha\times\beta)\times\gamma=\alpha\times(\beta\times\gamma)</math>

<math>2.(\alpha+\beta)\times\gamma\ne (\alpha\times\gamma)+(\beta\times\gamma), \alpha\times(\beta+\gamma)=(\alpha\times\beta)+(\alpha\times\gamma)</math>

例：

<math>\begin{align} (\omega+1)\times\omega&=\bigcup_{\gamma <\omega}((\omega+1) \times\gamma)\\&=\{(\omega+1)\times0,(\omega+1)\times1,(\omega+1)\times2,...\}\\&=\{0,\omega+1,\omega+(1+\omega)+1,\omega+(1+\omega)+(1+\omega)+1,...\}\\&={\rm sup}\{ 0,\omega+1,\omega\times2+1,\omega\times3+1,...\}=\omega^2 \\&\ne\omega\times(\omega+1)=\omega^2+\omega \end{align}</math>

'''Q:'''为什么不是<math>\omega^2+1</math>？

A: 我们知道<math>\omega^2+1=\omega^2\cup\{\omega^2\}=\{0,1,2,...,\omega,\omega+1,...,\omega\times2,...,\omega\times3,...,\omega^2\}</math>

而 <math>\bigcup_{\gamma <\omega}(\omega\times\gamma +1)</math> 中显然没有任何一个元素能够达到或是超过 <math>\omega^2</math>，因此它们的上确界也不会超过 <math>\omega^2</math>。

其实也可以换一个方向思考：既然 <math>{\rm sup}\{ \omega,\omega\times2,\omega\times3,...\}=\omega^2</math>

而 <math>{\rm sup}\{ 0,\omega+1,\omega\times2+1,\omega\times3+1,...\}</math> 中从小到大排列的每一项都比前者小，因此也不会超过 <math>\omega^2</math>。

==== 序数的指数运算 ====
<math>\alpha^0=1</math>

<math>\alpha^{\beta+1}=\alpha^\beta\times\alpha</math>

<math>\alpha^\beta=\bigcup_{\gamma <\beta}(\alpha^\gamma)</math>，如果 <math>\beta</math> 是极限序数。

序数的指数不具有对底数乘法的分配律，但指数加法具有对底数的分配律。即

<math>(\alpha\times\beta)^\gamma\ne\alpha^\gamma\times\beta^\gamma,\alpha^{\beta+\gamma}=\alpha^\beta\times\alpha^\gamma</math>

例：

<math>\begin{align} (2\times3)^\omega &=6^\omega=\bigcup_{\gamma <\omega}(6^\gamma)=\{6^0,6^1,6^2,... \}={\rm sup}\{1,6,36,... \}=\omega \\&\ne 2^\omega\times3^\omega=\bigcup_{\gamma <\omega}(2^\gamma)\times\bigcup_{\gamma <\omega}(3^\gamma)=\omega\times\omega=\omega^2 \end{align}</math>

<math>\varepsilon_0</math> 是第一个满足 <math>\omega^\alpha=\alpha</math> 的不动点。

<math>\omega^{\varepsilon_0}=\bigcup_{\gamma <\varepsilon_0}(\omega^\gamma)={\rm sup}\{1,\omega,\omega^2,...,\omega^\omega,...,\omega^{\omega^\omega},...\}=\varepsilon_0</math>

<math>\varepsilon_0\times\omega=\omega^{\varepsilon_0}\times\omega=\omega^{\varepsilon_0+1}</math>

=== 形式化定义 ===
'''序数和序数类'''

一个集合 <math>\alpha</math> 称为序数，当且仅当它满足以下条件：

* 传递性： <math>\alpha</math> 的每个元素都是其子集（<math>\forall\beta\in\alpha,\beta\subseteq\alpha</math>）
* 全序性：<math>\alpha</math> 上的关系 <math>\in</math> 是全序关系（<math>\forall\beta,\gamma\in\alpha,(\beta\in\gamma)\lor(\beta=\gamma)\lor(\beta\ni\gamma)</math>）
* 良基性：每个非空子集 <math>S\subseteq\alpha</math> 有最小元（<math>\exists\beta\in S(\forall\gamma\in S,\beta\notin\gamma)</math>）

等价地，序数可定义为良序集的序型，即与某个良序集同构的最小序数。

序数类是所有序数的总体，是一个真类，即：<math>\bold{On}\equiv\{\alpha|\alpha\text{ 是序数}\}</math>

其中，序数的成员关系满足以下性质：

* 三歧性：<math>\forall\alpha,\beta\in\bold{On},(\alpha\in\beta)\lor(\alpha=\beta)\lor(\alpha\ni\beta)</math>
* 传递性：<math>((\alpha\in\bold{On})\land(\beta\in\alpha))\rightarrow(\beta\in\bold{On})</math>
* 良序性：On 上的关系 ∈ 是良序的，即每个非空子类有最小元

'''后继序数和极限序数'''

一个序数 <math>\alpha</math> 称为后继序数，当且仅当存在序数 <math>\beta</math> 使得 <math>\alpha=\beta+1</math>（<math>\alpha\text{ 是后继序数}\Longleftrightarrow\exists\beta\in\bold{On}(\alpha=\beta+1)</math>）

一个序数 <math>\alpha</math> 称为后继序数，当且仅当不存在序数 <math>\beta</math> 使得 <math>\alpha=\beta+1</math>（<math>\alpha\text{ 是极限序数}\Longleftrightarrow\neg\exists\beta\in\bold{On}(\alpha=\beta+1)</math>）

'''递归函数'''

一个部分函数 <math>f:\omega\rightarrow\omega</math> 称为递归函数，当且仅当存在图灵机 <math>M</math> 满足：对任意 <math>n\in\omega</math>，

* 若 <math>n\in\text{dom}(f)</math>，则 <math>M</math> 在输入 <math>n</math> 时会在有限步内停机，并输出 <math>f(n)</math>；
* 若 <math>n\notin\text{dom}(f)</math>，则 <math>M</math> 在输入 <math>n</math> 时永不停机。

定义所有递归函数的类为 <math>\bold{Rec}_\text{f}</math>。

'''超限归纳'''

设 <math>\varphi(x)</math> 是一个性质。如果对所有序数 <math>\alpha</math> ，以下都成立：

* 如果对所有的 <math>\beta<\alpha</math> 都有 <math>\varphi(\beta)</math> 成立，那么 <math>\varphi(\alpha)</math> 成立

那么 <math>\varphi(\alpha)</math> 对所有序数 <math>\alpha</math> 成立。

等价地，设 <math>\varphi(x)</math> 是一个性质。如果以下都成立：

* <math>\varphi(0)</math> 成立
* 对于后继序数 <math>\alpha+1</math> ，若 <math>\varphi(\alpha)</math> 成立，则 <math>\varphi(\alpha+1)</math> 成立
* 对于极限序数 <math>\alpha</math> ，若对于所有 <math>\beta<\alpha</math> 有 <math>\varphi(\beta)</math> 成立，则 <math>\varphi(\alpha)</math> 成立

那么 <math>\varphi(\alpha)</math> 对所有序数 <math>\alpha</math> 成立。

'''超限递归'''

设 <math>\beta</math> 是一个序数，<math>f:\omega\rightarrow\omega</math> 是一个递归函数。通过超限递归定义一个函数 <math>F:\bold{On}\rightarrow\bold{On}</math>，满足：

* 对后继序数 <math>\alpha=\gamma+1</math>，定义 <math>F(\alpha)=f(\langle\gamma,F(\gamma)\rangle)</math>；
* 对极限序数 <math>\alpha</math>，定义 <math>F(\alpha)=\sup\{F(\gamma)|\gamma<\alpha\}</math>。

定义 <math>F_f</math> 是由 <math>f</math> 定义的超限递归函数。

称 <math>\alpha</math> 是 <math>f</math> 相对于 <math>\beta</math> 的序数，当且仅当存在递归函数 <math>f\in\bold{Rec}_\text{f}</math>，使得 <math>\alpha=F(\beta)</math>（即 <math>\alpha</math> 是通过 <math>f</math> 在 <math>b</math> 处的超限递归生成的序数），其中 <math>F</math> 是通过 <math>f</math> 定义的超限递归函数。

称 <math>\alpha</math> 是递归在 <math>\beta</math> 上的序数，当且仅当存在递归函数 <math>f\in\bold{Rec}_\text{f}</math> 和序数 <math>\gamma<\beta</math>，使得 <math>\alpha=F_f(\gamma)</math>。

'''递归序数和非递归序数'''

一个序数 <math>\alpha</math> 称为递归序数，当且仅当存在递归函数 <math>f\in\bold{Rec}_\text{f}</math> 和序数 <math>\beta</math>，使得 <math>\alpha</math> 是 <math>f</math> 相对于 <math>\beta</math> 的序数（<math>\alpha\text{ 是递归序数}\Longleftrightarrow\exists f\in\bold{Rec}_\text{f}\ \exists\beta\in\bold{On}(\alpha=F_f(\beta))</math>）

递归序数类是所有递归序数的总体：<math>\bold{Rec}\equiv\{\alpha|\alpha\text{ 是递归序数}\}</math>

一个序数 <math>\alpha</math> 称为非递归序数，当且仅当它不是递归序数，即 <math>\alpha\text{ 是非递归序数}\Longleftrightarrow\alpha\in\bold{On}\land\alpha\notin\bold{Rec}</math>（<math>\alpha\text{ 是非递归序数}\Longleftrightarrow\neg\exists f\in\bold{Rec}_\text{f}\ \exists\beta\in\bold{On}(\alpha=F_f(\beta))</math>）

'''容许序数'''

一个序数 <math>\alpha</math> 称为容许序数，当且仅当构造宇宙 <math>L_\alpha</math> 满足 Kripke-Platek 集合论的公理。等价地，<math>\alpha</math> 是容许的当且仅当对任何递归在 <math>\alpha</math> 上的函数 <math>F:L_\alpha\rightarrow L_\alpha</math>，其定义域和值域都属于 <math>L_\alpha</math>（即 <math>\alpha</math> 对递归封闭）。

<math>\alpha\text{ 是容许序数}\Longleftrightarrow L_\alpha\vDash\bold{KP}</math>

'''Church-Kleene 序数（[[CKO]]）'''

<math>\omega_\alpha^\text{CK}</math> 序数通过超限递归定义：

* <math>\omega_0^\text{CK}=\omega</math>
* 对后继序数 <math>\alpha=\beta+1</math>，<math>\omega_\alpha^\text{CK}=\sup\{\alpha\in\bold{On}|\alpha\text{ 是递归在 }\omega_\beta^\text{CK}\text{ 上的序数}\}</math>
* 对极限序数 <math>\alpha</math>，<math>\omega_\alpha^\text{CK}=\sup\{\omega_\beta^\text{CK}|\beta<\alpha\}</math>

第一个非递归序数 <math>\omega_1^\text{CK}</math> 是所有递归序数的最小上界（即上确界），即：<math>\omega_1^\text{CK}=\sup\{\alpha\in\bold{On}|\alpha\in\bold{Rec}\}</math>，它是可数的最小非递归序数。

'''序数的基本列'''

对极限序数 <math>\lambda</math>，其基本列定义为递增序列 <math>\langle\lambda[\xi]\rangle_{\xi<\mu}</math>（<math>\mu</math> 为序数），满足： <math>\forall\xi<\mu,\lambda[\xi]<\lambda</math> 且 <math>\sup\{\lambda[\xi]|\xi<\mu\}=\lambda</math>。

若 <math>\lambda</math> 是正则序数（<math>\text{cf}(\lambda)=\lambda</math>），则 <math>\mu=\lambda</math>；若 <math>\lambda</math> 是奇异序数（<math>\text{cf}(\lambda)<\lambda</math>），则 <math>\mu=\text{cf}(\lambda)</math>。

[[分类:入门]]

[[分类:集合论相关]]

PrSS的良序性

2025-08-15T08:45:29Z

Apocalypse：/* PrSS 标准式集的序型 */

== PrSS 没有无穷降链 ==

首先我们将 [[初等序列系统|PrSS]] 的每个合法表达式 <math>S</math> 对应于一个不超过 <math>\varepsilon_0</math> 的[[序数]] <math>F(S)</math>。然后我们证明 PrSS 表达式展开时，其对应的序数严格递减。于是就可以依据 <math>\varepsilon_0</math> 的[[良序|良序性]]说明 PrSS 没有无穷降链。

'''第一步'''：将 PrSS 的每个合法表达式对应于一个不超过 <math>\varepsilon_0</math> 的序数。

对 PrSS 表达式的长度归纳定义。

任取 PrSS 合法表达式 <math>S=(a_1,a_2,\cdots,a_n)</math>。

若 <math>n=0</math>，则 <math>F(S)=0<\varepsilon_0</math>。

若 <math>n>0</math>，分两种情况讨论：

* 若 <math>\forall i\in\{2,3,\cdots,n\},a_i\neq 0</math>，则取 <math>T=(a_2-1,a_3-1,\cdots,a_n-1)</math>。<br>不难验证，<math>T</math> 是合法的 PrSS 表达式，且 <math>T</math> 的长度比 <math>S</math> 的长度短。令 <math>F(S)=\omega^{F(T)}</math>。<br>因为 <math>F(T)<\varepsilon_0</math>，所以 <math>F(S)<\varepsilon_0</math>。
* 否则，设 <math>S</math> 中有 <math>r</math> 项为零，且 <math>a_{k_1}=a_{k_2}=\cdots=a_{k_r}=0</math>，其中 <math>1=k_1<k_2<k_3<\cdots<k_r<k_{r+1}=n+1</math>。<br>取 <math>S_i=(a_{k_i},a_{k_i+1},\cdots,a_{k_{i+1}-1}),\quad i=1,2,\cdots,r</math>，不难验证 <math>S_1,S_2,\cdots,S_r</math> 都是合法的 PrSS 表达式，且它们的长度都比 <math>S</math> 短。<br>令 <math>F(S)=F(S_1)+F(S_2)+\cdots+F(S_r)</math>。<br>因为 <math>F(S_1),F(S_2),\cdots,F(S_r)<\varepsilon_0</math>，所以 <math>F(S)<\varepsilon_0</math>。

'''第二步'''：证明 PrSS 表达式展开时，其对应的序数严格递减。

对 PrSS 表达式的长度归纳证明。

任取 PrSS 表达式 <math>S=(a_1,a_2,\cdots,a_n)</math>。

若 <math>n=0</math>，则 <math>S</math> 无法展开。下面讨论 <math>n>0</math> 的情况。

若 <math>a_n=0</math>，则 <math>S</math> 的展开式（前驱表达式）是 <math>T=(a_1,a_2,\cdots,a_{n-1})</math>。分为两种情况讨论：

* 若 <math>\forall i\in\{2,3,\cdots,n\},a_i\neq 0</math>，则 <math>S=(0)</math>，<math>F(S)=1</math>，<math>T=()</math>，<math>F(T)=0</math>，<math>F(T)<F(S)</math>。
* 否则，设 <math>S</math> 中有 <math>r</math> 项为零，且 <math>a_{k_1}=a_{k_2}=\cdots=a_{k_r}=0</math>，其中 <math>1=k_1<k_2<k_3<\cdots<k_r=n<k_{r+1}=n+1</math>。<br>取 <math>S_i=(a_{k_i},a_{k_i+1},\cdots,a_{k_{i+1}-1}),\quad i=1,2,\cdots,r</math>，则 <math>F(S)=F(S_1)+F(S_2)+\cdots+F(S_r)</math>。<br>注意到 <math>S_r=(0)</math>，<math>F(S_r)=1</math>，所以 <math>F(T)=F(S_1)+F(S_2)+\cdots+F(S_{r-1})</math>，所以 <math>F(S)=F(T)+1>F(T)</math>。

若 <math>a_n\neq 0</math>，分为三种情况讨论：

* 若 <math>S</math> 中有不止一项是零。<br>设 <math>S</math> 中有 <math>r>1</math> 项为零，且 <math>a_{k_1}=a_{k_2}=\cdots=a_{k_r}=0</math>，其中 <math>1=k_1<k_2<k_3<\cdots<k_r<k_{r+1}=n+1</math>。<br>取 <math>S_i=(a_{k_i},a_{k_i+1},\cdots,a_{k_{i+1}-1}),\quad i=1,2,\cdots,r</math>，则 <math>F(S)=F(S_1)+F(S_2)+\cdots+F(S_r)</math>。<br>设 <math>S</math> 的坏根为 <math>a_x</math>。不难看出，<math>x\ge k_r</math>。<br>设 <math>S_r</math> 的基本列的第 <math>p</math> 项是 <math>V_p</math>。由 PrSS 展开规则，<math>S</math> 的基本列的第 <math>p</math> 项是 <math>U_p=(S_1,S_2,\cdots,S_{r-1},V_p)</math>。<br>因为 <math>S_r</math> 的长度比 <math>S</math> 短，根据归纳假设，有 <math>F(V_p)<F(S_r)</math>。<br>设 <math>V_p=(b_1,b_2,\cdots,b_m)</math> 中有 <math>s</math> 项为零，且 <math>b_{l_1}=b_{l_2}=\cdots=b_{l_s}=0</math>，其中 <math>1=l_1<l_2<l_3<\cdots<l_s<l_{s+1}=m+1</math>。<br>取 <math>T_i=(b_{l_i},b_{l_i+1},\cdots,b_{l_{i+1}-1}),\quad i=1,2,\cdots,s</math>，则 <math>F(V_p)=F(T_1)+F(T_2)+\cdots+F(T_s)</math>。<br>所以 <math display="block">\begin{aligned}F(U_s)\,&=F(S_1)+F(S_2)+\cdots+F(S_{r-1})+F(T_1)+F(T_2)+\cdots+F(T_s)\\&=F(S_1)+F(S_2)+\cdots+F(S_{r-1})+(F(T_1)+F(T_2)+\cdots+F(T_s))\\&=F(S_1)+F(S_2)+\cdots+F(S_{r-1})+F(V_s)\\&<F(S_1)+F(S_2)+\cdots+F(S_{r-1})+F(S_r)\\&=F(S)\end{aligned}</math>
* 若 <math>S</math> 中仅有首项为零，且末项为 <math>a_n=1</math>。<br>令 <math>T_1=(a_1,a_2,\cdots,a_{n-1})</math>。由 PrSS 展开规则，不难看出 <math>S</math> 的基本列的第 <math>p</math> 项是 <math>U_p=(T_1,T_1,\cdots,T_1)</math>，其中有 <math>p</math> 个 <math>T_1</math>。<br>显然 <math>n\ge 2</math>，所以 <math>F(T_1)>0</math>。<br>那么 <math>F(U_p)=F(T_1)+F(T_1)+\cdots+F(T_1)=F(T_1)\times p<F(T_1)\times\omega</math>。<br>令 <math>T_2=(a_2-1,a_3-1,\cdots,a_n-1)</math>，则 <math>F(S)=\omega^{F(T_2)}</math>。<br>令 <math>T_3=(a_2-1,a_3-1,\cdots,a_{n-1}-1)</math>，则 <math>F(T_1)=\omega^{F(T_3)}</math>。<br>因为 <math>a_n-1=0</math>，所以 <math>F(T_2)=F(T_3)+1</math>，所以 <math>F(S)=\omega^{F(T_2)}=\omega^{F(T_3)+1}=\omega^{F(T_3)}\times\omega=F(T_1)\times\omega>F(U_p)</math>。
* 若 <math>S</math> 中仅有首项为零，且末项为 <math>a_n\neq 1</math>。<br>令 <math>T=(a_2-1,a_3-1,\cdots,a_n-1)</math>，因为 <math>a_n-1\neq 0</math>，所以 <math>T</math> 是极限表达式。<br>设 <math>T</math> 的基本列的第 <math>k</math> 项是 <math>T_k=(b_1,b_2,\cdots,b_{m_k})</math>，则由 PrSS 展开规则可以看出 <math>S</math> 的基本列的第 <math>k</math> 项是 <math>S_k=(0,b_1+1,b_2+1,\cdots,b_{m_k}+1)</math>。<br>根据归纳假设有 <math>F(T_k)<F(T)</math>，所以 <math>F(S_k)=\omega^{F(T_k)}<\omega^{F(T)}=F(S)</math>。

证毕。

以上，我们证明了 PrSS 表达式的展开过程不会无限进行，即不存在无穷降链。

至此，PrSS 已经是一个合格的序数记号了。但我们不止于此，我们要给出判断 PrSS 表达式是否标准的方法，并证明 PrSS 标准式的序是字典序。

== PrSS 标准表达式 ==

PrSS 的极限基本列是 <math>(),(0),(0,1),(0,1,2),\cdots</math>。PrSS 的极限基本列的第 <math>n</math> 项是 <math>L_n=(0,1,2,\cdots,n-1)</math>。

'''定义'''（PrSS 标准表达式）

一个 PrSS 表达式 <math>S</math> 是 '''PrSS 标准表达式'''（简称 '''PrSS 标准式'''），当且仅当存在 <math>n</math> 使得极限基本列的第 <math>n</math> 项 <math>L_n</math> 可以经过若干次展开得到 <math>S</math>。

简单地说，标准式就是能从极限基本列展开得到的表达式。对于大部分的序数记号，存在合法但不标准的表达式。这些不标准的合法表达式往往也能对应于一个序数（例如上一节的映射 <math>F</math> 不要求表达式是标准的），但这将导致不同的合法表达式对应于同一个序数。对应于同一个序数的不同合法表达式，例如 <math>(0,1)</math> 和 <math>(0,0,1)</math> 都是对应于 <math>\omega</math> 的表达式，彼此之间无法展开成对方。这意味着合法表达式集不是全序，更不是良序。不同的标准表达式则不会对应于同一个序数，标准表达式集确实是良序的。

在这一节，我们将给出 PrSS 标准式的必要条件。该条件实际上也是充分的，不过充分性将在下一节证明。在此之前，我们先来定义字典序的概念。

'''定义'''（字典序）

设 <math>A</math> 是一个全序集，其上的全序是 <math>\le</math>。考虑两个数列 <math>S=(a_1,a_2,\cdots,a_n)</math> 和 <math>T=(b_1,b_2,\cdots,b_m)</math>，其中 <math>a_1,a_2,\cdots,a_n,b_1,b_2,\cdots,b_m\in A</math>。在字典序下，<math>S\le T</math> 当且仅当以下两条中的一条成立：
* 存在 <math>0\le k<\min\{n,m\}</math> 使得对任意 <math>i\in\{1,2,\cdots,k\}</math> 有 <math>a_i=b_i</math>，但 <math>a_{k+1}<b_{k+1}</math>；
* 对任意 <math>i\in\{1,2,\cdots,\min\{n,m\}\}</math> 有 <math>a_i=b_i</math>，且 <math>n\le m</math>。

不难看出，对任意两个由 <math>A</math> 中元素组成的有限数列 <math>S,T</math>，总有 <math>S\le T\lor T\le S</math>。也就是说，字典序是全序。

'''引理'''

PrSS 表达式展开时，字典序变小。

'''证明'''

设 <math>S=(a_1,a_2,\cdots,a_n)</math> 是 PrSS 表达式。

如果 <math>a_n=0</math>，则 <math>S</math> 的展开式为 <math>T=(a_1,a_2,\cdots,a_{n-1})</math>。根据定义，对任意 <math>i\in\{1,2,\cdots,n-1\}</math> 有 <math>a_i=a_i</math>，且 <math>n-1<m</math>，所以 <math>T<S</math>。

如果 <math>a_n\neq 0</math>，且展开式 <math>T</math> 是 <math>S</math> 的基本列的第 <math>0</math> 项，则 <math>T</math> 相当于删去 <math>S</math> 的末项，所以 <math>T<S</math>。

如果 <math>a_n\neq 0</math>，且展开式 <math>T</math> 是 <math>S</math> 的基本列的第 <math>k>0</math> 项，则 <math>T</math> 相当于删去 <math>S</math> 的末项，并复制若干次坏部。因为坏部的第一项（坏根）小于末项，所以 <math>T<S</math>。

证毕。

现在可以给出 PrSS 标准式的必要条件了。

'''临时定义'''（PrSS 规范式）

对表达式 <math>S=(a_1,a_2,\cdots,a_n)</math> 的长度 <math>n</math> 归纳定义。

若 <math>n=0</math>，则 <math>S=()</math> 是 PrSS 规范式。

若 <math>n>0</math> 且 <math>S</math> 中仅有首项是零，则 <math>S</math> 是 PrSS 规范式当且仅当 <math>(a_2-1,a_3-1,\cdots,a_n-1)</math> 是 PrSS 规范式。

若 <math>n>0</math> 且 <math>S</math> 中有 <math>r>1</math> 项是零，设 <math>a_{k_1}=a_{k_2}=\cdots=a_{k_r}=0</math>，其中 <math>1=k_1<k_2<\cdots<k_r<k_{r+1}=n+1</math>，令 <math>S_i=(a_{k_i},a_{k_i+1},\cdots,a_{k_{i+1}-1})</math>。则 <math>S</math> 是 PrSS 规范式当且仅当 <math>S_1,S_2,\cdots,S_r</math> 都是 PrSS 规范式且按字典序 <math>S_1\ge S_2\ge\cdots\ge S_r</math>。

PrSS 规范式是本文临时定义的，并不是通用术语。PrSS 规范式实际上等价于 PrSS 标准式。

'''定理'''

PrSS 标准式都是 PrSS 规范式。

'''证明'''

不难看出 PrSS 极限基本列都是 PrSS 规范式，因此只需证明 PrSS 规范式的展开式也是 PrSS 规范式即可。

对规范表达式 <math>S=(a_1,a_2,\cdots,a_n)</math> 的长度 <math>n</math> 归纳证明。

<math>n=0,1</math> 的情况是平凡的，下面讨论 <math>n>1</math> 的情况。

若 <math>S</math> 中有 <math>r>1</math> 项是零，设 <math>a_{k_1}=a_{k_2}=\cdots=a_{k_r}=0</math>，其中 <math>1=k_1<k_2<\cdots<k_r<k_{r+1}=n+1</math>，令 <math>S_i=(a_{k_i},a_{k_i+1},\cdots,a_{k_{i+1}-1})</math>。则 <math>S</math> 的展开相当于 <math>S_r</math> 的展开。根据归纳假设，<math>S_r</math> 的展开式是规范的。因为 <math>S_r</math> 展开后字典序会变小（引理），所以 <math>S</math> 展开后，各部分的字典序依然递减，所以 <math>S</math> 的展开式是规范的。注意这里要讨论 <math>S_r</math> 的展开式有不止一个零的情况，不过这个讨论并不难，感兴趣的读者可以自行讨论。

若 <math>S</math> 中仅有一项是零，且 <math>a_n=1</math>。令 <math>T_1=(a_2-1,a_3-1,\cdots,a_n-1)</math>。因为 <math>S</math> 是规范表达式，根据规范表达式的定义，<math>T_1</math> 也是规范表达式。从规范表达式的定义中不难看出，去掉 <math>T_1</math> 末尾的 <math>a_n-1=0</math> 后依然是规范的，即 <math>T_2=(a_2-1,a_3-1,\cdots,a_{n-1}-1)</math> 规范。所以 <math>T=(a_1,a_2,\cdots,a_{n-1})</math> 规范。注意到 <math>S</math> 的展开式形如 <math>(T,T,\cdots,T)</math>，所以 <math>S</math> 的展开式是规范的。

若 <math>S</math> 中仅有一项是零，且 <math>a_n\neq 1</math>。令 <math>T=(a_2-1,a_3-1,\cdots,a_n-1)</math>。因为 <math>S</math> 规范，所以 <math>T</math> 规范。根据归纳假设，<math>T</math> 的展开式是规范的。设 <math>S</math> 的一个展开式是 <math>(b_1,b_2,\cdots,b_m)</math>，则由 PrSS 展开规则可知 <math>(b_2-1,b_3-1,\cdots,b_m-1)</math> 是 <math>T</math> 的展开式，是规范的，所以 <math>S</math> 的展开式也是规范的。

证毕。

在第一节证明 PrSS 没有无穷降链时，我们使用了序数的良序性。如果想不依赖序数就证明 PrSS 没有无穷降链，参见知乎用户 www620 的证明<ref>https://zhuanlan.zhihu.com/p/13871622947</ref>。这个证明依赖本节的两个结论：PrSS 表达式展开时字典序变小、PrSS 标准式都是规范式。注意到本节的两个结论不依赖第一节，所以没有循环论证的问题。

== PrSS 标准式集的良序性 ==

上一节我们证明了 PrSS 合法表达式在展开过程中字典序变小，并由此得到了 PrSS 标准式的必要条件。这一节，我们证明字典序变小反过来也意味着可以展开得到，并由此得到 PrSS 标准式的充分条件。

'''定理'''

设 <math>S,T</math> 是 PrSS 规范式，且按字典序 <math>S<T</math>，则 <math>S</math> 经过若干次展开可以得到 <math>T</math>。

注意上一节的引理对任意 PrSS 合法式均成立，而这个定理要求 <math>S,T</math> 都是规范式。

'''证明'''

定义一种特殊的展开函数 <math>E</math>：设 PrSS 表达式 <math>U</math> 的基本列为 <math>U_0,U_1,U_2,\cdots</math>。若存在 <math>i</math> 使得按字典序 <math>U_i\ge S</math>，则取 <math>k=\min\{i\mid U_i\ge S\}</math> 并定义 <math>E(U)=U_k</math>。如果对任意 <math>i</math> 都有按字典序 <math>U_i<S</math>，则取 <math>E(U)=U</math>。如果 <math>U</math> 是后缀表达式，则取 <math>U_0=U_1=\cdots</math> 为 <math>U</math> 的前驱表达式。特殊地，如果 <math>U</math> 是零表达式，则 <math>E(U)=U</math>。

从 <math>E</math> 的定义不难看出，如果按字典序 <math>U\ge S</math>，则按字典序 <math>E(U)\ge S</math>。令 <math>T_0=T</math>，<math>T_{n+1}=E(T_n)</math>。因为按字典序 <math>T>S</math>，所以对任意 <math>i</math> 都有按字典序 <math>T_i\ge S</math>。

而第一节已经证明 PrSS 不存在无穷降链，所以存在 <math>k</math> 使得 <math>T_k=T_{k+1}=\cdots</math>。讨论一下不难得到，这时有两种可能：

* <math>T_k=S</math>。
* 按字典序 <math>T_k>S</math>，但 <math>T_k</math> 的基本列的每一项都按字典序小于 <math>S</math>。进一步讨论还可以看出，这种情况下 <math>T_k</math> 一定是极限表达式。

前一种情况命题已经成立，只需要用反证法证明后一种情况不存在即可。

若存在，设 <math>T_k</math> 的好部是 <math>G</math>，坏部是 <math>B</math>，末项是 <math>L</math>，坏根是 <math>L-1</math>，则 <math>T_k=(G,B,L)</math>，而 <math>T_k</math> 的展开式形如 <math>(G,B,B,\cdots)</math>。

如果 <math>S</math> 按字典序小于 <math>T_k</math> 而大于 <math>(G,B,B,\cdots)</math>，那么 <math>S</math> 一定以 <math>(G,B)</math> 开头。设 <math>S=(G,B,X)</math>，那么 <math>X</math> 的首项等于坏根 <math>L-1</math>，而 <math>X</math> 按字典序大于 <math>(B,B,\cdots)</math>。

这与 <math>S</math> 是规范表达式相矛盾。这个矛盾可以更明确地写出来，但会占据大量篇幅且可能不会提供新的见解，所以在此略。也许以后我会补充。

证毕。

至此，我们已经证明了，规范表达式集上由展开定义的序，等价于字典序。

'''定理'''

PrSS 规范式都是 PrSS 标准式。

'''证明'''

设 <math>S</math> 是 PrSS 规范式。存在 <math>n</math> 使得 <math>T=(0,1,2,\cdots,n-1)</math> 按字典序大于 <math>S</math>。根据上一个定理，<math>T</math> 可以展开成 <math>S</math>，所以 <math>S</math> 是 PrSS 标准式。

证毕。

至此，我们证明了 PrSS 没有无穷降链、PrSS 标准式集的序是字典序，而字典序是全序，所以 PrSS 标准式集上的序是良序。

但我们不止于此。下一节，我们要证明 PrSS 标准式集[[良序|序同构]]于 <math>\varepsilon_0</math>。

== PrSS 标准式集的序型 ==

为了证明 PrSS 标准式集[[良序|序同构]]于 <math>\varepsilon_0</math>，我们要证明第一节定义的保序映射 <math>F</math> 是 PrSS 标准式集和 <math>\varepsilon_0</math> 之间的双射，结合 PrSS 标准式集的全序性，就能说明 <math>F</math> 是 PrSS 标准式集和 <math>\varepsilon_0</math> 之间的序同构。

'''定理'''

<math>F</math>是 PrSS 标准式集与<math>\varepsilon_0</math>之间的保序双射。

'''证明'''

对于小于<math>\varepsilon_0</math>的序数<math>\alpha</math>，定义<math>Seq(\alpha)=(a_1,a_2,\cdots,a_k)</math>是这样的自然数序列：

* <math>Seq(0)=()</math>为空序列
* <math>\alpha>0</math>时，设它的康托范式为<math>\alpha=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_n}</math>，则<math>Seq(\alpha)=T(S'(\alpha_1),S'(\alpha_2),\cdots,S'(\alpha_n))</math>，其中<math>T</math>为序列的拼合，而如果<math>Seq(\alpha)=(a_1,a_2,\cdots,a_k)</math>，<math>S'(\alpha)</math>定义为<math>(0,a_1+1,a_2+1,\cdots,a_k+1)</math>

我们给出几个引理：

'''引理1''' 如果<math>\varepsilon_0>\alpha\geq\beta</math>，则按字典序<math>Seq(\alpha)\geq{Seq(\beta)}</math>

'''引理2''' <math>Seq(\alpha)</math>是 PrSS 的规范式。

'''引理3''' <math>F(Seq(\alpha))=\alpha</math>

'''引理4''' <math>Seq(F(S))=S</math>，其中<math>S</math>为 PrSS 规范式

'''引理1的证明''' 取出所有有序对<math>(\alpha,\beta)</math>使<math>\varepsilon_0>\alpha>\beta</math>但按字典序<math>Seq(\alpha)\leq{Seq(\beta)}</math>，取出其中<math>\alpha</math>最小的一组。写出它们的康托范式：

<math>\alpha=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_p}</math>

<math>\beta=\omega^{\beta_1}+\omega^{\beta_2}+\omega^{\beta_3}+\cdots +\omega^{\beta_q}</math>

则以下两点成立其一：
# 存在某个<math>i\leq{min\{p,q\}}</math>使<math>\alpha_i>\beta_i</math>
# <math>q<p</math>，且对于所有<math>i\leq{q}</math>有<math>\alpha_i=\beta_i</math>

对于前者，由于<math>\alpha_i<\alpha</math>，根据<math>\alpha</math>的最小性，字典序下<math>Seq(\alpha_i)>Seq(\beta_i)</math>，根据定义，字典序下<math>Seq(\alpha)>Seq(\beta)</math>，矛盾。

对于后者，易知<math>Seq(\beta_i)</math>是<math>Seq(\alpha_i)</math>删去后面数项得到的子序列。故字典序下<math>Seq(\alpha)>Seq(\beta)</math>，矛盾。

因此，这样的有序对<math>(\alpha,\beta)</math>不存在，所以如果<math>\varepsilon_0>\alpha\geq\beta</math>，则按字典序<math>Seq(\alpha)\geq{Seq(\beta)}</math>

又如果<math>\varepsilon_0>\alpha=\beta</math>，则按字典序<math>Seq(\alpha)=Seq(\beta)</math>。于是引理1得证。

'''引理2的证明''' 设<math>\alpha<\varepsilon_0</math>是最小使得<math>Seq(\alpha)</math>不是 PrSS 的规范式的序数。设它的康托范式为<math>\alpha=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_n}</math>。

(1) 若<math>n=1</math>，<math>\alpha=\omega^{\alpha_1}</math>，<math>Seq(\alpha)=S'(\alpha_1)</math>。根据定义，<math>Seq(\alpha)</math>是 PrSS 的规范式当且仅当<math>Seq(\alpha_1)</math>是 PrSS 的规范式，而<math>\alpha_1<\alpha</math>，根据最小性，<math>Seq(\alpha_1)</math>是 PrSS 的规范式，故<math>Seq(\alpha)</math>也是 PrSS 的规范式，矛盾。

(2) 若<math>n>1</math>，<math>\alpha=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_n}</math>，<math>Seq(\alpha)=T(S'(\alpha_1),S'(\alpha_2),\cdots,S'(\alpha_n))</math>。根据定义，<math>Seq(\alpha)</math>是 PrSS 的规范式当且仅当每个<math>Seq(\alpha_k)</math>均是 PrSS 的规范式且<math>Seq(\alpha_k)</math>的字典序不增，<math>k=1,2,\cdots,n</math>。前者是显然的(类似于上文的(1)部分)，而后者由<math>\alpha_1\geq\alpha_2\geq\cdots\alpha_n</math>和引理1保证。于是<math>Seq(\alpha)</math>是 PrSS 的规范式，矛盾。

故这样的<math>\alpha<\varepsilon_0</math>不存在。引理2得证。

'''引理3的证明''' 设<math>\alpha<\varepsilon_0</math>是最小的不满足<math>F(Seq(\alpha))=\alpha</math>的序数。它的康托范式为<math>\alpha=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_n}</math>。

则有<math>Seq(\alpha)=T(S'(\alpha_1),S'(\alpha_2),\cdots,S'(\alpha_n))</math>。根据定义，<math>F(T(S'(\alpha_1),S'(\alpha_2),\cdots,S'(\alpha_n)))=F(S'(\alpha_1))+F(S'(\alpha_2))+\cdots+F(S'(\alpha_n))=\omega^{F(Seq(\alpha_1))}+\omega^{F(Seq(\alpha_2))}+\cdots+\omega^{F(Seq(\alpha_n))}</math>，而<math>\alpha_k<\alpha</math>，<math>k=1,2,\cdots,n</math>，根据最小性，<math>F(Seq(\alpha_k))=\alpha_k</math>，故<math>F(T(S'(\alpha_1),S'(\alpha_2),\cdots,S'(\alpha_n)))=\omega^{\alpha_1}+\omega^{\alpha_2}+\omega^{\alpha_3}+\cdots +\omega^{\alpha_n}=\alpha</math>。矛盾。

故这样的<math>\alpha<\varepsilon_0</math>不存在。引理3得证。

'''引理4的证明''' 若对于某个 PrSS 规范式<math>S</math>有<math>Seq(F(S))>S</math>，则由引理1得<math>F(Seq(F(S))>F(S)</math>，由引理3得<math>F(S)>F(S)</math>，矛盾。同理，<math>Seq(F(S))<S</math>则<math>F(S)<F(S)</math>，矛盾。故<math>Seq(F(S))=S</math>。

'''定理的证明''' 由引理1~4，<math>F</math>有逆映射<math>Seq</math>，且<math>Seq</math>保序。于是<math>Seq</math>(和其逆<math>F</math>)是 PrSS 标准式集与<math>\varepsilon_0</math>之间的序同构。

证毕。

[[分类:证明]]

ω-Y

2025-08-15T05:55:57Z

Apocalypse：

<math>\omega\mathrm{-Y}</math>，是一种[[Beklemishev's Worm|Worm]]型序数记号。

== 定义 ==

=== 合法表达式 ===
一个合法的<math>\omega\mathrm{-Y}</math>表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 <math>\omega\mathrm{-Y}</math> 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
<math>\omega\mathrm{-Y}</math>的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于<math>\omega\mathrm{-Y}</math>的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。'''与<math>\mathrm{1-Y}</math>相同：
* 行标现在可以是一个超限序数，例如第<math>\omega</math>行。
* 一些项现在可以不赋予任何数作为取值，这些项称为空项，记作<math>\varnothing</math>。'''
第<math>\alpha</math>行第<math>j</math>列的项记为<math>x_{\alpha,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 后继序数行的父项 & 阶差项 ====
对于后继序数<math>\alpha+1</math>和非空项<math>x_{\alpha+1,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧非空项<math>x_{\alpha+1,k}</math>：

* <math>k<j</math>且<math>x_{\alpha+1,k}<x_{\alpha+1,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于第0行的项<math>x_{0,j}</math>，它的父项是与它位于同一行，且同时满足<math>k<j</math>和<math>x_{0,k}<x_{0,j}</math>的最右侧项<math>x_{0,k}</math>。

如果满足上述条件的项不存在，那么<math>x_{\alpha+1,j}</math>(或者<math>x_{0,j}</math>)的父项不存在。特别地，等于1的项的父项不存在。

对于任何序数<math>\alpha</math>，项<math>x_{\alpha,j}</math>：
* 如果它有父项<math>x_{\alpha,k}</math>，则它的阶差项为<math>x_{\alpha+1,j}=x_{\alpha,j}-x_{\alpha,k}</math>。
* 如果它没有父项，或者为空项，它的阶差项为<math>x_{\alpha,j}=\varnothing</math>。

由于第<math>\alpha</math>行的项的阶差项构成了第<math>\alpha+1</math>行，称第<math>\alpha+1</math>行的序列是第<math>\alpha</math>行的序列的'''阶差序列'''。

==== 极限序数行的父项 ====
上述定义只给出了后继序数行的项的取值和父项关系。接下来给出极限序数的情形：

设极限序数<math>\alpha=\beta+\omega^k<\omega^\omega</math>，<math>\beta</math>为极限序数，<math>k</math>是正整数。

取出最大的序数<math>\gamma<\omega^k</math>使得<math>x_{\beta+\gamma,j}</math>不为空项，这些项<math>x_{\beta+\gamma,j}</math>称为顶端元素。如果这样的<math>\gamma</math>不存在，则记顶端元素为空项。

对于任何项<math>x_{\delta,j}</math>，定义如下概念：
* 取出最大的<math>\delta_1</math>使得<math>\delta_1<\delta</math>且<math>x_{\delta_1,j}</math>有父项，记为<math>x_{\delta_1,k}</math>，然后取出最大的<math>\delta_2</math>使得<math>\delta_1\leq\delta_2\leq\delta</math>且<math>x_{\delta_2,k}</math>非空。得到的<math>x_{\delta_2,k}</math>称为<math>x_{\delta,j}</math>的待定父项。

对于顶端元素<math>x_{\beta+\gamma,j}</math>定义如下概念：
* 如果顶端元素为空项，或<math>\gamma=0</math>，则<math>x_{\alpha,j}=\varnothing</math>。
* 否则，从<math>x_{\beta+\gamma,j}</math>开始不断取待定父项，得到第一个小于<math>x_{\beta+\gamma,j}</math>的项，记为<math>x_{\delta,k}</math>。则令<math>x_{\alpha,j}=x_{\beta+\gamma,j}-x_{\delta,k}</math>，称<math>x_{\alpha,k}</math>为<math>x_{\alpha,j}</math>的拟父项。

对于极限序数<math>\alpha</math>和大于1的项<math>x_{\alpha,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧项<math>x_{\alpha,k}</math>：

* <math>k<j</math>，<math>x_{\alpha,k}</math>非空且<math>x_{\alpha,k}<x_{\alpha,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟祖先项。

这里“拟祖先项”的定义是：一个元素自己，以及它的拟父项、拟父项的拟父项......共同构成它的拟祖先项。

如果满足上述条件的项不存在，那么<math>x_{\alpha,j}</math>的父项不存在。另外，等于1的项的父项不存在。

''注：此处的“拟父项/拟祖先项”是编者引入的等价的临时定义。在主流的定义与教程中，通常使用山脉图(见下文)定义此部分内容。''

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{\alpha,n}</math>，它的父项设为<math>x_{\alpha,r}</math>。如果在计算到某行(第<math>\gamma</math>行)时有<math>x_{\gamma,n}-x_{\gamma,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''。

以上给出了<math>\omega\mathrm{-Y}</math>极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述<math>\omega\mathrm{-Y}</math>的展开规则或者直观理解部分定义，需要用到'''山脉图'''的辅助。

''(不会写了，要不直接复制一下教程)''

网站[https://naruyoko.github.io/MEGAwhYmountain MEGAwhY mountain]可以绘制<math>\omega\mathrm{-Y}</math>的山脉图。

''(待补充附有配图的ω-Y山脉图绘制例子)''

== 展开 ==
''(还是不会写，要不直接复制一下教程)''

== 枚举 ==
''(开摆!)''

== <math>\mathrm{n-Y}</math>序列 ==

== <math>\mathrm{C\ n-Y}\&\mathrm{D\ n-Y}</math> ==

== 参考资料 ==
[[分类:记号]]

Y序列

2025-07-29T02:50:55Z

Apocalypse：

'''<math>\mathrm{Y}</math>序列'''，一般指<math>\mathrm{1-Y}</math>，一种[[Beklemishev's Worm|Worm]]型序数记号。

== 定义 ==

=== 合法表达式 ===
一个合法的 <math>\mathrm{1-Y}</math> 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 <math>\mathrm{1-Y}</math> 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
<math>\mathrm{1-Y}</math> 的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 <math>\mathrm{1-Y}</math> 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。'''与 <math>\mathrm{0-Y}</math> 不同的是：
* 行标现在可以是一个超限序数，例如第<math>\omega</math>行。
* 一些项现在可以不赋予任何数作为取值，这些项称为空项，记作<math>\varnothing</math>。'''
第<math>\alpha</math>行第<math>j</math>列的项记为<math>x_{\alpha,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 后继序数行的父项 & 阶差项 ====
对于后继序数<math>\alpha+1</math>和非空项<math>x_{\alpha+1,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧非空项<math>x_{\alpha+1,k}</math>：

* <math>k<j</math>且<math>x_{\alpha+1,k}<x_{\alpha+1,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于第0行的项<math>x_{0,j}</math>，它的父项是与它位于同一行，且同时满足<math>k<j</math>和<math>x_{0,k}<x_{0,j}</math>的最右侧项<math>x_{0,k}</math>。

如果满足上述条件的项不存在，那么<math>x_{\alpha+1,j}</math>(或者<math>x_{0,j}</math>)的父项不存在。特别地，等于1的项的父项不存在。

对于任何序数<math>\alpha</math>，项<math>x_{\alpha,j}</math>：
* 如果它有父项<math>x_{\alpha,k}</math>，则它的阶差项为<math>x_{\alpha+1,j}=x_{\alpha,j}-x_{\alpha,k}</math>。
* 如果它没有父项，或者为空项，它的阶差项为<math>x_{\alpha,j}=\varnothing</math>。

由于第<math>\alpha</math>行的项的阶差项构成了第<math>\alpha+1</math>行，称第<math>\alpha+1</math>行的序列是第<math>\alpha</math>行的序列的'''阶差序列'''。

==== 极限序数行的父项 & 提取 ====
上述定义只给出了后继序数行的项的取值和父项关系。接下来给出极限序数的情形：

设极限序数<math>\alpha=\beta+\omega<\omega^2</math>，<math>\beta</math>为极限序数。则定义项<math>x_{\alpha,j}</math>如下：

取出最大的非负整数<math>p</math>使得<math>x_{\beta+p,j}</math>不为空项，则<math>x_{\alpha,j}=x_{\beta+p,j}</math>。这些项<math>x_{\beta+p,j}</math>称为主项。

对大于1的项<math>x_{\alpha,j}</math>定义如下概念：
# 设<math>x_{\alpha,j}=x_{\beta+p,j}</math>，令<math>a=j</math>。
# 设<math>x_{\beta+p-1,a}</math>的父项为<math>x_{\beta+p-1,k}</math>。如果<math>x_{\beta+p-1,k}</math>是主项，或者<math>x_{\beta+p,k}</math>是主项，称<math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟父项。
# 否则令<math>a=k</math>并回到第2步，直到找到某个主项，设其列标是<math>l</math>，称<math>x_{\alpha,l}</math>是<math>x_{\alpha,j}</math>的拟父项。

对于极限序数<math>\alpha</math>和大于1的项<math>x_{\alpha,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧项<math>x_{\alpha,k}</math>：

* <math>k<j</math>且<math>x_{\alpha,k}<x_{\alpha,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟祖先项。

这里“拟祖先项”的定义是：一个元素自己，以及它的拟父项、拟父项的拟父项......共同构成它的拟祖先项。

如果满足上述条件的项不存在，那么<math>x_{\alpha,j}</math>的父项不存在。另外，等于1的项的父项不存在。

以上定义项<math>x_{\alpha,j}</math>时，将所有位于<math>\beta</math>到<math>\beta+\omega</math>之间的行中每一列的最上方非空项取了出来，并“提”到了<math>\alpha=\beta+\omega</math>行(还保留了其下的一些父项关系)，这就是'''提取(Extraction)'''的含义。

''注：此处的“主项”，“拟父项/拟祖先项”是编者引入的等价的临时定义。在主流的定义与教程中，通常使用山脉图(见下文)定义此部分内容。''

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{\alpha,n}</math>，它的父项设为<math>x_{\alpha,r}</math>。如果在计算到某行(第<math>\gamma</math>行)时有<math>x_{\gamma,n}-x_{\gamma,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''。

以上给出了 <math>\mathrm{1-Y}</math> 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述 <math>\mathrm{1-Y}</math> 的展开规则或者直观理解部分定义，需要用到'''山脉图'''的辅助。

<math>\mathrm{1-Y}</math> 的山脉图作图难度略高于[[0-Y]]。对于 <math>\mathrm{1-Y}</math> 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则逐行向上求出各项，直到某次提取的所有主项全为1，不进行这次提取。

接下来，对于第后继序数<math>\alpha+1</math>行，进行如下操作：

取出所有非空项<math>x_{\alpha+1,j}</math>。对于每个<math>x_{\alpha,j}</math>，用竖直线段连接<math>x_{\alpha+1,j}</math>的下端与<math>x_{\alpha,j}</math>的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math>称为它的端点。

设<math>x_{\alpha,j}</math>有父项<math>x_{\alpha,k}</math>，用斜线段连接<math>x_{\alpha+1,j}</math>的下端与<math>x_{\alpha,k}</math>的上端。这些斜线段称为'''左腿'''，<math>x_{\alpha,k}</math>称为它的端点。

接下来，对于第极限序数<math>\alpha=\beta+\omega</math>行，进行如下操作：

用虚线分别连接所有项<math>x_{\alpha,j}</math>的下端，和它们对应的主项<math>x_{\beta+p,j}</math>的上端。

对所有行各执行一次上述操作，就得到了<math>(a_1,a_2,\cdots,a_n)</math>的山脉图。

注意：有些情况下，山脉图只包含一行，即第0行。

<math>\mathrm{1-Y}</math> 的山脉图中，从一个有父项的项出发，沿右腿向上走一步，再沿左腿向下走一步，就能到达它的父项。

对于极限序数<math>\alpha</math>行的项<math>x_{\alpha,j}</math>，从其对应的主项<math>x_{\beta+p,j}</math>出发，沿左腿向下走一步，然后在保持行标不大于<math>\beta+p</math>的前提下，沿右腿向上走一步(如果可能)，重复此过程直到找到另一个主项，设其列标是<math>l</math>，则<math>x_{\alpha,l}</math>是<math>x_{\alpha,j}</math>的拟父项。

网站[https://naruyoko.github.io/whYmountain/ whY mountain]可以绘制 <math>\mathrm{1-Y}</math> 的山脉图。

''(待补充附有配图的1-Y山脉图绘制例子,以及绘制1-Y山脉图的网站(有吗),以及极限序数行父项关系的直观理解)''

== 展开 ==
<math>\mathrm{1-Y}</math> 的展开难度远高于[[0-Y]]。

对于 <math>\mathrm{1-Y}</math> 的极限表达式<math>\mathrm{Y}(a_1,a_2,\cdots,a_n)</math>，其基本列第<math>q</math>项可按以下方式确定：

先作出其山脉图，求出根列<math>r</math>，根列右侧的结构称为'''坏部'''。

设序列一共进行了<math>m</math>次提取操作，此时山脉图被分为<math>m+1</math>层，第<math>k</math>层的行标位于<math>\omega(k-1)</math>和<math>\omega k</math>之间。

<math>\mathrm{1-Y}</math> 的展开是从上到下逐层进行的。

对于最上面一层，其展开规则和 <math>\mathrm{0-Y}</math> 类似：

# 先将末列行标第二大的项<math>x_{\omega m+p,n}</math>减1(行标最大的项为1)，删除本层坏部第<math>\omega m+p</math>行以下元素的数值。
# 将本层的坏部平移并复制在山脉图末尾，复制<math>q-1</math>次。“坏部平移”是指左右腿及端点同时平移
# 特别地，如果某一条左腿的端点位于根列左侧，复制时左腿的端点不向右平移。
# 接下来，从根列右侧开始从上到下，每一行从左到右填入数字。对于某个位置，若其向上通过右腿移动到值为<math>x</math>的项，然后向左下通过左腿移动到值为<math>y</math>的项，则这个位置应填入<math>x+y</math>。

第<math>k(1\le k \le m)</math>层山脉图的展开需要引入几个概念<ref>Suzuka梅天狸：Y序列专题(4)——让我们请出主角登场(下) ，https://zhuanlan.zhihu.com/p/671375564</ref>：顶点元素、平移边、轮廓边、参考边。

顶点元素的定义如下：从本层根列的主项出发，重复“沿左腿向上走一步，再沿右腿向下走若干步(终点的行标不能低于起点)”，得到的所有主项称为顶点元素。或者说，顶点元素是在提取之后以根列为“拟祖先项”的主项。

平移边、轮廓边、参考边的定义和顶点元素有关：

* '''轮廓边'''：从一个顶点元素出发，重复“沿左腿向上走一步，再沿右腿向下走一步”直至无路可走，中间经过的所有边称为轮廓边。
* '''平移边'''：根列右侧的非轮廓边称为平移边。
* '''参考边'''：从本层根列的主项出发，得到的所有轮廓边称为参考边。取基本列第<math>q</math>项时，根列右边的结构需要循环复制<math>q-1</math>次。在每一轮复制的过程中，三种边的行为如下：

* 平移边只需要简单地向右平移。特别地，若左腿的端点位于根列左侧，则左腿的端点保持不动。这一点和 <math>\mathrm{0-Y}</math> 的规则类似。
* 轮廓边在向右平移的同时，还需要向上提升它的高度。具体来说，提升的高度为最右列和根列顶点元素的高度差。
* 参考边在向右平移后，还要向上复制，用来填补平移边和轮廓边之间的空隙。

在所有的边复制完成之后，我们还是按照从上到下、从左到右的顺序向山脉图填入数字。

首先，本层每一列最上方的项等于上层最底行(即第<math>\omega k</math>行)对应项，即保持虚线两端的对应关系

填充完最上方的数字之后，按照之前相同的规则继续填充其它项，就得到了第<math>k</math>层的山脉图。

从第最上面一层开始，依次对每一层进行复制和填充，直到填充完第1层，得到第0行的序列就是<math>\mathrm{Y}(a_1,a_2,\cdots,a_n)</math>的基本列第<math>q</math>项。

== 枚举 ==
''(开摆!)''

== <math>\mathrm{n-Y}</math>序列 ==
通过某种方式，我们可以把 <math>\mathrm{1-Y}</math> 前面的参数1扩展到任意大的自然数<math>n</math>。详细信息请参考[[ω-Y]]页面。

== 参考资料 ==
[[分类:记号]]

0-Y

2025-07-29T02:40:46Z

Apocalypse：

<math>\mathrm{0-Y}</math>是一种 [[Beklemishev's Worm|Worm]] 型序数记号，它是 [[初等序列系统|PrSS]] 的一种扩展。

== 定义 ==

=== 合法表达式 ===
一个合法的 <math>\mathrm{0-Y}</math> 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和 <math>(1,1,4,5,1,4)</math> 都是合法的 <math>\mathrm{0-Y}</math> 表达式，而 <math>(1,2,\pi)</math> 不是。

=== 结构 ===
<math>\mathrm{0-Y}</math> 的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指 <math>n=0</math> 的表达式，即空序列；
* '''后继表达式'''指 <math>n>0,a_n=1</math> 的表达式，即末项为 1 的非空序列；
* '''极限表达式'''指 <math>n>0,a_n>1</math> 的表达式，末项不为 1 的非空序列。

对于 <math>\mathrm{0-Y}</math> 的一个极限表达式 <math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第 1,2,... 列，从下往上是第 0,1,... 行。第 <math>i</math> 行第 <math>j</math> 列的项记为 <math>x_{i,j}</math>。

初始时，我们有 <math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 父项与阶差项 ====
等于 1 的项没有父项。对于大于 1 的项<math>x_{i,j}</math>，它的父项与它位于同一行，且是满足以下条件的最右侧项 <math>x_{i,k}</math>：

* <math>k<j</math> 且 <math>x_{i,k}<x_{i,j}</math>。
* 如果 <math>i>0</math>，还要求 <math>x_{i-1,k}</math> 是 <math>x_{i-1,j}</math> 的祖先项。

这里“祖先项”的定义类似于 [[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于 <math>x_{i,j}</math>，如果它有父项 <math>x_{i,k}</math>，则它的阶差项为 <math>x_{i+1,j}=x_{i,j}-x_{i,k}</math>；如果 <math>x_{i,j}=1</math>，则它的阶差项 <math>x_{i+1,j}=1</math>。

由于第 <math>i</math> 行的项的阶差项构成了第 <math>i+1</math> 行，称第 <math>i+1</math> 行的序列是第 <math>i</math> 行的序列的'''阶差序列'''。

==== 末列与坏根 ====
第 <math>n</math> 列称为'''末列'''。

对于末列的某一项 <math>x_{i,n}</math>，它的父项设为 <math>x_{i,r}</math>。如果在计算到某行（第 <math>p</math> 行）时有 <math>x_{p,n}-x_{p,r}=1</math>，则称 <math>a_r</math> 为'''坏根'''，称第 <math>r</math> 列为'''根列'''，并且不再计算第 <math>p+1</math> 行及之后的行。

以上给出了 <math>\mathrm{0-Y}</math>极限表达式 <math>(a_1,a_2,\cdots,a_n)</math> 的完整寻找坏根流程。

== 山脉图 ==
要描述 <math>\mathrm{0-Y}</math> 的展开规则，需要用到'''山脉图'''的辅助。对于 <math>\mathrm{0-Y}</math> 的一个极限表达式 <math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则画出第 0 到 <math>p</math> 行。现在你有了一个 <math>p\times{n}</math> 的“矩阵”（第 0 至第 <math>p</math> 行，第 1 至第 <math>n</math> 列），接下来，对于第 <math>i</math> 行，<math>0\leq{i}\leq{p-1}</math> 进行如下操作：

对于每个 <math>x_{i,j}</math>，用竖直线段连接 <math>x_{i+1,j}</math> 的下端与 <math>x_{i,j}</math> 的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math> 称为它的端点。

对于每个大于 1 的 <math>x_{i,j}</math>，设 <math>x_{i,j}</math> 有父项 <math>x_{i,k}</math>，用斜线段连接 <math>x_{i+1,j}</math> 的下端与 <math>x_{i,k}</math> 的上端。这些斜线段称为'''左腿'''，<math>x_{i,k}</math> 称为它的端点。

对第 1 到第 <math>p</math> 行各执行一次上述操作，就得到了 <math>(a_1,a_2,\cdots,a_n)</math> 的山脉图。

山脉图有以下性质：从一个有父项的元素出发，沿右腿向上走一步，再沿左腿向下走一步，就能到达它的父项。

注意：有些情况下，山脉图只包含一行，即第 0 行。

注：由于山脉图的某一行只和其下的项有关，你也可以在逐行往上填写阶差序列的同时画出山脉图。许多常见的 <math>\mathrm{0-Y}</math> 教程都采用这个方法。
[[文件:0y1463797.png|缩略图]]
以 <math>\mathrm{0-Y}(1,4,6,3,7,9,7)</math> 为例，其山脉图如右图所示。由于第2行末项2的阶差为1，故不再继续计算。

''(待补充绘制0-Y山脉图的网站(有吗))''

== 展开 ==
对于 <math>\mathrm{0-Y}</math> 的一个表达式 <math>(a_1,a_2,\cdots,a_n)</math>：

* 如果它是零表达式，它对应序数 0。
* 如果它是后继表达式，它对应 <math>(a_1,a_2,\cdots,a_{n-1})</math> 的后继。
* 如果它是极限表达式，它的基本列第 <math>q</math> 项如下确定：
*# 作出 <math>p\times{n}</math> 的山脉图。称位于根列右侧的结构（包括阶差项和其对应的山脉图中的左右腿，不包括根列）为'''坏部'''，其余为'''好部'''。
*# 删除坏部中第 <math>p</math> 行以下的所有项，并将 <math>x_{p,n}</math> 减 1。
*# 接下来，保留山脉图的好部不动，将坏部平移并复制在山脉图末尾，复制 <math>q-1</math> 次。“坏部平移”是指左右腿及端点同时平移。
*# 特别地，如果某一条左腿的端点位于根列左侧，复制时左腿的端点不向右平移。
*# 接下来，你得到了根列右侧的一系列山脉图和第 <math>p</math> 行的一系列项。从根列右侧开始，从上到下，每一行从左到右，按照以下方式填入正整数：对于某个位置，向上通过右腿移动到值为 <math>x</math> 的项，然后向左下通过左腿移动到值为 <math>y</math> 的项，则回到初始位置并填上 <math>x+y</math>。
*# 最后得到的第 0 行的序列，就是 <math>(a_1,a_2,\cdots,a_n)</math> 展开的基本列第 <math>q-1</math> 项。

<math>\mathrm{0-Y}</math> 的极限基本列是 <math>\{(1,2),(1,3),(1,4),\cdots\}</math>，从这个基本列中元素开始取前驱或取基本列所能得到的表达式是 0-Y 的标准式。

例 1：<math>\mathrm{0-Y}(1,4,6,4)[3]</math>

先作出它的山脉图，从图中可以得到：根列为第 1 列，坏部为第 2、3、4 列。
[[文件:0-Y(1,4,6,4).png|居中|缩略图]]
然后，将坏部第 2 行以下的数删除，并将其整体平移并复制 2 次。
[[文件:0-Y(1,4,6,4)展开(1).png|居中|缩略图]]
接着，依次向山脉图中的“空位”填入正整数，注意所填的数满足“一个数等于其右腿和左腿连接的数之差”。
[[文件:0-Y(1,4,6,4)展开(2).png|居中|缩略图]]
最后，根据山脉图的第 0 行，我们得到了 <math>\mathrm{0-Y}(1,4,6,4)[3]=\mathrm{0-Y}(1,4,6,3,7,10,6,11,15,10)</math>。

例 2：<math>\mathrm{0-Y}(1,4,6,3,7,9,7)[3]</math>

其山脉图已经在[[0-Y#山脉图|前面]]给出。从图中可以得到：根列为第 4 列，坏部为第 5、6、7 列。

注意：第 2 行第 6 列的“1”的左腿的另一端（位于第 1 列）在根列左侧，故在复制时，其另一端点保持不动。

复制、填充后得到的山脉图如下。
[[文件:0-Y(1,4,6,3,7,9,7)展开.png|居中|缩略图]]
因此 <math>\mathrm{0-Y}(1,4,6,3,7,9,7)[3]=\mathrm{0-Y}(1,4,6,3,7,9,6,11,13,10,16,18,15)</math>

== 枚举 ==
我们使用 [[Bashicu矩阵|BMS]] 对 <math>\mathrm{0-Y}</math> 进行简单分析（左边是 <math>\mathrm{BMS}</math>，右边是 <math>\mathrm{0-Y}</math>）。

<math>(0)=1</math>

<math>(0)(1)=1,2</math>

<math>(0)(1)(1)=1,2,2</math>

<math>(0)(1)(2)=1,2,3</math>

<math>(0)(1)(2)(3)=1,2,3,4</math>

<math>(0)(1,1)=1,3</math>

<math>(0)(1,1)(1,0)=1,3,2</math>

<math>(0)(1,1)(1,0)(2,1)=1,3,2,4</math>

<math>(0)(1,1)(1,1)=1,3,3</math>

<math>(0)(1,1)(2,0)=1,3,4</math>

<math>(0)(1,1)(2,0)(3,1)=1,3,4,6</math>

<math>(0)(1,1)(2,1)=1,3,5</math>

<math>(0)(1,1)(2,1)(3,1)=1,3,5,7</math>

<math>(0)(1,1)(2,2)=1,3,6</math>

<math>(0)(1,1)(2,2)(3,3)=1,3,6,10</math>

<math>(0)(1,1,1)=1,4</math>

<math>(0)(1,1,1)(1,0,0)(2,1,1)=1,4,2,5</math>

<math>(0)(1,1,1)(1,1,0)=1,4,3</math>

<math>(0)(1,1,1)(1,1,0)(2,2,1)=1,4,3,7</math>

<math>(0)(1,1,1)(1,1,1)=1,4,4</math>

<math>(0)(1,1,1)(2,0,0)=1,4,5</math>

<math>(0)(1,1,1)(2,1,0)=1,4,6</math>

<math>(0)(1,1,1)(2,1,0)(1,1,1)=1,4,6,4</math>

<math>(0)(1,1,1)(2,1,0)(3,1,0)=1,4,6,8</math>

<math>(0)(1,1,1)(2,1,0)(3,2,1)=1,4,6,10</math>

<math>(0)(1,1,1)(2,1,1)=1,4,7</math>

<math>(0)(1,1,1)(2,1,1)(3,1,1)=1,4,7,10</math>

<math>(0)(1,1,1)(2,2,0)=1,4,8</math>

<math>(0)(1,1,1)(2,2,1)=1,4,9</math>

<math>(0)(1,1,1)(2,2,2)=1,4,10</math>

<math>(0)(1,1,1)(2,2,2)(3,3,3)=1,4,10,20</math>

<math>(0)(1,1,1,1)=1,5</math>

<math>(0)(1,1,1,1,1)=1,6</math>

<math>\cdots</math>

两者极限相等。

== 与 [[Bashicu矩阵|BMS]] 的互译 ==
事实上，<math>\mathrm{0-Y}</math> 与 [[Bashicu矩阵|BMS]] 的标准式之间有十分简单的互译关系。

对于一个 <math>\mathrm{0-Y}</math> 标准表达式，作出其山脉图，但不考虑末列的影响，而是无限地逐行向上作出阶差序列，直到得到的序列全为 1。

现在你有了一个 <math>t\times{n}</math> 的山脉图，行标为 0 到 <math>t</math>，列标为 1 到 <math>n</math>。

定义 <math>b_{i,j}</math> 如下：

* <math>x_{i,j}=1</math> 时 <math>b_{i,j}=0</math>
*否则设 <math>x_{i,j}</math> 的父项为 <math>x_{i,k}</math>，令 <math>b_{i,j}=b_{i,k}+1</math>

最后得到的矩阵 <math>(b_{i,j})</math> 删去最顶上全为 0 的行，并以水平线为轴镜像，即可得到等价的 <math>\mathrm{BMS}</math>。

对于一个 <math>\mathrm{BMS}</math> 标准式 <math>(d_{i,j})</math>（第 1 至第 <math>t</math> 行，第 1 至第 <math>n</math> 列），定义 <math>e_{i,j}</math> 如下：

* <math>d_{i,j}=0</math> 时 <math>e_{i,j}=1</math>
* 否则设 <math>d_{i,j}</math> 的父项为 <math>d_{i,k}</math>，令 <math>e_{i,j}=e_{i,k}+e_{i+1,j}</math>（如果 <math>i=t</math>，我们规定 <math>e_{i+1,j}=1</math>）

最后取出 <math>f_k=e_{1,k}</math>，即为等价的 <math>\mathrm{0-Y}</math> 序列。

然而，尽管目前已有的分析均支持以上结论，目前对此尚未有严格的证明。

<math>\mathrm{BMS}</math> 和 <math>\mathrm{0-Y}</math> 的互相转换可以使用 [https://fiveyeargaokao.github.io/googology/bms-0y%E4%B8%80%E9%94%AE%E8%BD%AC%E6%8D%A2.html BMS 0-Y Converter Made By FiveYearGaoKao]。

== 与 [[Y序列|Y 序列]] 的关系 ==
<math>\mathrm{0-Y}</math> 虽然名字里带有 '''Y'''，但它与 [[Y序列|Y 序列]]的内核有较大差异。

历史上，<math>\mathrm{0-Y}</math> 的出现晚于通常的 <math>\mathrm{Y}</math> 序列，而且强度也远低于 <math>\mathrm{Y}</math> 序列。事实上，<math>\mathrm{0-Y}</math> 是仿照 <math>\mathrm{BMS}</math> 制作出来的。

[[分类:记号]]

Fake Fake Fake Zeta

2025-07-26T09:52:21Z

Apocalypse：/* 末项，核与层数 */

'''Fake Fake Fake Z(FFFZ)'''，是由yahtzee于2022年提出，后续由国内的大数研究者夏夜星空完善的'''前沿记号'''。

== 定义 ==
'''注意：FFFZ的定义尚未完全确定，且有较为频繁的更改(大部分是修改一些小问题)。这里叙述最新一版(2025.7.26)的定义。'''

'''注意：部分概念的定义被修改为了等价版本。这些修改与原始文本之间是逻辑意义上的等价。'''

=== 主体规则 ===
FFFZ的合法表达式形如<math>\psi_Z[\#](n)</math>，极限基本列为<math>\{\psi_Z(0),\psi_Z(\psi_Z(0)),\psi_Z(\psi_Z(\psi_Z(0))),\cdots\}</math>。

# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>
# 如果<math>[\#,m,n]</math>存在，<math>\psi_Z[\#,m](n)[s]=f^s(n)</math>，其中<math>f(x)=\psi_Z[\#,m,n](x)</math>
# 如果<math>[\#,m,n]</math>不存在，<math>\psi_Z[\#,m](n)[s]=\psi_Z[\#,m](n[t+s])</math>。其中<math>t</math>定义如下：
* 如果<math>m\geq{n}</math>，那么<math>t=0</math>。
* 如果<math>m<n</math>，那么<math>t</math>是满足<math>n[t]\geq{m}</math>的最小非负整数。

=== 化简规则 ===
* <math>\psi_Z[\#,m](n)=\psi_Z[\#](n)</math>，<math>m>n</math>
* <math>\psi_Z[](n)=\psi_Z(n)</math>

为了判定<math>[\#]</math>的存在性，定义以下概念：

=== 名称解释 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，记它的末项为<math>Endseq(\#)=\alpha_m</math>。

对于序数<math>\alpha</math>，写出它的Cantor范式<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>。称<math>\omega^{\alpha_n}</math>为<math>\alpha</math>的末项。

如果<math>\alpha</math>等于它的末项，称<math>\alpha</math>为'''简单序数'''，否则为'''复合序数'''。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#](n)</math>：
# 如果<math>n</math>是后继序数，称<math>\alpha</math>是<math>+</math>型极限，或0级极限，等级为0。
# 如果<math>[\#,n]</math>不存在，称<math>\alpha</math>是<math>\omega</math>型极限，或1级极限，等级为1。
# 如果<math>[\#,n]</math>存在，称<math>\alpha</math>是<math>\varepsilon</math>型极限，或2级极限，等级为2。

对于两个非零简单序数<math>\alpha</math>和<math>\beta</math>：
# 如果<math>\alpha</math>的等级大于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>高等。
# 如果<math>\alpha</math>的等级等于<math>\beta</math>的等级，称<math>\alpha</math>和<math>\beta</math>同等。
# 如果<math>\alpha</math>的等级小于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>低等。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#,m](n)</math>：
# 如果<math>[\#,m,n]</math>不存在，则<math>\alpha</math>的根为<math>n</math>。
# 如果<math>[\#,m,n]</math>存在，则<math>\alpha</math>的根为<math>m</math>。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z(n)</math>，则它的根为<math>n</math>。

对于序数<math>\alpha</math>：
# 如果它是复合序数，它形如<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>，则每个<math>\omega^{\alpha_k}</math>被它直接包含。
# 如果它是非零简单序数，它形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>，则每个<math>\alpha_k</math>均被它直接包含，<math>n</math>也被它直接包含。
# 如果它是0，没有任何序数被它直接包含。

<math>\alpha</math>直接包含<math>\beta</math>，记为<math>dInc(\beta,\alpha)</math>。

接下来是几个较为复杂的定义。

==== 末项，核与层数 ====
对于非零序数<math>\alpha</math>和简单序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的末项是以下两个序数<math>u</math>中较大者：
* <math>u</math>是满足“<math>u<s</math>，且存在序数<math>v</math>使<math>v+u=\alpha</math>”的最大序数。
* <math>u</math>是满足“<math>u</math>是简单序数且存在序数<math>w</math>，使得<math>\alpha=u\times{w}</math>”的最大序数。
* 如果上述两个规则中某条规则没有任何序数<math>u</math>能够满足，那么忽视那条规则。

<math>\alpha</math>关于<math>s</math>的末项记为<math>End(\alpha,s)</math>。特别地，<math>\alpha</math>关于<math>0</math>的末项与上文定义的末项等价，记为<math>End(\alpha)</math>。

对于序数<math>\alpha</math>，序数<math>s</math>，不小于-1的整数<math>k</math>，<math>\alpha</math>关于<math>s</math>的<math>k</math>层核，记为<math>Ker(\alpha,s,k)</math>，定义如下：
* <math>Ker(\alpha,s,-1)=\alpha</math>
* <math>Ker(0,s,k)=0</math>

以下假设<math>\alpha</math>非零，<math>k</math>是非负整数：
* <math>Ker(\alpha,s,k)=Ker(End(\alpha),End(s),k)</math>

以下假设<math>\alpha</math>和<math>s</math>都是非零简单序数，<math>k</math>是非负整数，<math>\alpha</math>形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>：
* <math>Ker(\alpha,s,0)=\psi_Z[End(\alpha_1,s),End(\alpha_2,s),\cdots,End(\alpha_m,s)](End(n,s))</math>
* <math>Ker(\alpha,s,k+1)=Ker(\psi_Z[Ker(\alpha_1,s,k),Ker(\alpha_2,s,k),\cdots,Ker(\alpha_m,s,k)](Ker(n,s,k)),s,0)</math>

对于序数<math>\alpha</math>，其层数是一个非负整数，记为<math>Lev(\alpha)</math>，定义如下：

* <math>Lev(0)=0</math>
* <math>Lev(\alpha)=max\{Lev(\beta)\mid{dInc(\beta,\alpha)}\}+1</math>

对于非零序数<math>\alpha</math>，序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的核记为<math>Ker(\alpha,s)</math>，它定义为<math>Ker(\alpha,s)=Ker(\alpha,s,Lev(\alpha))</math>。

特别地，<math>\alpha</math>的核记为<math>Ker(\alpha)</math>，它定义为<math>Ker(\alpha)=Ker(\alpha,0,Lev(\alpha))</math>。

=== 双元兼容 ===
对于序数<math>\alpha=\psi_Z[\#](n)</math>和<math>\beta=\psi_Z[\&](m)</math>，依次进行以下判定：
# 如果<math>\alpha>\beta</math>，则<math>[\alpha,\beta]</math>存在。
# 如果<math>\alpha</math>和<math>\beta</math>中至少有一个复合序数，则<math>[\alpha,\beta]</math>存在当且仅当<math>[End(\alpha),End(\beta)]</math>存在。
# 如果<math>\alpha=0</math>，则<math>[\alpha,\beta]</math>不存在。
# 当<math>\#=\&</math>时，<math>[\alpha,\beta]</math>存在当且仅当<math>[n,m]</math>存在；否则，如果存在序列<math>\%</math>使得<math>End(Endseq(\%))</math>与<math>End(Endseq(\#))</math>，<math>End(Endseq(\&))</math>之一相等，且存在序数<math>x</math>和序数<math>y</math>使得<math>\alpha=\psi_Z[\%](x)</math>且<math>\beta=\psi_Z[\%](y)</math>，则若<math>[x,y]</math>存在那么<math>[\alpha,\beta]</math>存在
# 如果<math>\beta\geq\psi_Z[\alpha](\alpha)</math>，则<math>[\alpha,\beta]</math>存在当且仅当<math>[\alpha,\beta</math>的根<math>]</math>存在；否则，如果存在简单序数<math>s</math>和不小于-1的整数<math>k</math>，使得<math>Ker(\beta,s,k)\geq\psi_Z[Ker(\alpha,s,k)](Ker(\alpha,s,k))</math>且不存在非零序数<math>x</math>和序列<math>\%</math>使得<math>Ker(\beta,s,k)=\psi_Z[Ker(\alpha,s,k)\times\omega,\%](Ker(\alpha,s,k)\times{x})</math>，则当<math>[\alpha,\beta</math>的根<math>]</math>存在时<math>[\alpha,\beta]</math>存在
# 如果存在两个序数<math>A</math>，<math>B</math>，<math>Ker(A)=Ker(\alpha)</math>，<math>Ker(B)=Ker(\beta)</math>，<math>A</math>属于<math>B</math>基本列，且<math>\alpha</math>比<math>\beta</math>高等，则<math>[\alpha,\beta]</math>存在
# 如果通过上述规则均无法说明<math>[\alpha,\beta]</math>存在，则<math>[\alpha,\beta]</math>不存在

=== 多元兼容 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，如果任取满足<math>k>j</math>的<math>\alpha=\alpha_j</math>，<math>\beta=\alpha_k</math>都有'''以下两个条件至少成立一个'''，则<math>[\#]</math>存在。

条件I：以下两个条件至少成立一个：
# <math>[\alpha,\beta]</math>存在
# <math>k<m</math>且存在满足<math>k>l</math>的<math>\gamma=\alpha_l</math>，使得<math>[\gamma,\beta]</math>不存在

条件II：对于任何满足<math>k<l</math>的<math>\gamma=\alpha_l</math>，存在简单序数<math>s</math>，不小于-1的整数<math>n</math>，使得以下两个条件同时成立：
# <math>[\beta,\gamma]</math>存在，且<math>Ker(\alpha,s,n)>Ker(\beta,s,n)</math>
#

''(好吧还没写完(因为看不懂)。除了这条规则(平移转移)，特殊规则以及各种优先级，还要补不少定义域限制，比如“m为序数或空”之类)''

== 直观解释 ==
FFFZ的前几条规则是
# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>

类似于BOCF的规则。为了提升强度，我们需要引入“兼容”的概念。

“兼容”就是中括号里的东西(有时也叫“伪链”，伪即Fake)，通过类似于“挡刀”的方式提升强度。举个例子：对<math>\psi_Z(n)</math>取极限，得到的并不是<math>\psi_Z(\omega)</math>，而是<math>\psi_Z[\omega](\omega)</math>，中括号内出现了挡刀的<math>\omega</math>。只有达到<math>\alpha\to\psi_Z[\omega](\alpha)</math>的第一个不动点时，才能得到<math>\psi_Z(\omega)</math>。

当然，我们并不局限于只把一个序数放进兼容里。兼容里可以有多个序数，举个例子：对<math>\psi_Z[\omega^2](\omega^2+n)</math>取极限，得到的并不是<math>\psi_Z[\omega^2](\omega^2+\omega)</math>，而是<math>\psi_Z[\omega^2,\omega^2+\omega](\omega^2+\omega)</math>。

从提升强度的角度考虑，我们当然希望设计一套规则，允许更多的兼容，从而最大限度地提升强度。但是，这样的规则并不是总是可行——考虑这样的规则：“任意一系列极限序数可以兼容”，那么我们有

<math>\psi_Z(\omega)\to\psi_Z[\omega](\psi_Z[\omega](\omega))\to\psi_Z[\omega](\psi_Z[\omega](2))\to\psi_Z[\omega](\omega\times{2})\to\psi_Z[\omega,\omega\times{2}](\psi_Z[\omega,\omega\times{2}](\omega\times{2}))\to\psi_Z[\omega,\omega\times{2}](\omega\times{3})\to\cdots</math>

无穷降链。

造成这种结果的原因在于，<math>[\omega,\omega\times{2},\omega\times{3},\cdots]</math>这些序数可以无限地兼容下去，形成'''无限兼容链'''。所以，我们希望的规则应该满足以下两个条件：

1. 允许兼容存在，以提升强度。

2. 不允许某些兼容存在，以避免无限兼容链。

由于实际分析和构造的需要，我们还有第三个条件：

3. 允许某些关键节点的特殊兼容存在。

基于上述的理念，作者给出了上文提到的那一系列规则。

''(未完待续。主要是补充一些概念的直观理解，比如“末项”之类的)''

== 衍生版本 ==
上文介绍的版本称为<math>\rm{Strong}</math>版本。除此之外，还有<math>\rm{Actual}</math>版本和<math>\rm{Weak}</math>版本，各版本区别如下：

=== <math>\rm{Actual}</math>版本 ===
''(等待补充)''

=== <math>\rm{Weak}</math>版本 ===
''(等待补充)''

== 分析 ==

[[分类:前沿]]
[[分类:记号]]

Fake Fake Fake Zeta

2025-07-26T09:11:33Z

Apocalypse：

'''Fake Fake Fake Z(FFFZ)'''，是由yahtzee于2022年提出，后续由国内的大数研究者夏夜星空完善的'''前沿记号'''。

== 定义 ==
'''注意：FFFZ的定义尚未完全确定，且有较为频繁的更改(大部分是修改一些小问题)。这里叙述最新一版(2025.7.26)的定义。'''

'''注意：部分概念的定义被修改为了等价版本。这些修改与原始文本之间是逻辑意义上的等价。'''

=== 主体规则 ===
FFFZ的合法表达式形如<math>\psi_Z[\#](n)</math>，极限基本列为<math>\{\psi_Z(0),\psi_Z(\psi_Z(0)),\psi_Z(\psi_Z(\psi_Z(0))),\cdots\}</math>。

# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>
# 如果<math>[\#,m,n]</math>存在，<math>\psi_Z[\#,m](n)[s]=f^s(n)</math>，其中<math>f(x)=\psi_Z[\#,m,n](x)</math>
# 如果<math>[\#,m,n]</math>不存在，<math>\psi_Z[\#,m](n)[s]=\psi_Z[\#,m](n[t+s])</math>。其中<math>t</math>定义如下：
* 如果<math>m\geq{n}</math>，那么<math>t=0</math>。
* 如果<math>m<n</math>，那么<math>t</math>是满足<math>n[t]\geq{m}</math>的最小非负整数。

=== 化简规则 ===
* <math>\psi_Z[\#,m](n)=\psi_Z[\#](n)</math>，<math>m>n</math>
* <math>\psi_Z[](n)=\psi_Z(n)</math>

为了判定<math>[\#]</math>的存在性，定义以下概念：

=== 名称解释 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，记它的末项为<math>Endseq(\#)=\alpha_m</math>。

对于序数<math>\alpha</math>，写出它的Cantor范式<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>。称<math>\omega^{\alpha_n}</math>为<math>\alpha</math>的末项。

如果<math>\alpha</math>等于它的末项，称<math>\alpha</math>为'''简单序数'''，否则为'''复合序数'''。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#](n)</math>：
# 如果<math>n</math>是后继序数，称<math>\alpha</math>是<math>+</math>型极限，或0级极限，等级为0。
# 如果<math>[\#,n]</math>不存在，称<math>\alpha</math>是<math>\omega</math>型极限，或1级极限，等级为1。
# 如果<math>[\#,n]</math>存在，称<math>\alpha</math>是<math>\varepsilon</math>型极限，或2级极限，等级为2。

对于两个非零简单序数<math>\alpha</math>和<math>\beta</math>：
# 如果<math>\alpha</math>的等级大于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>高等。
# 如果<math>\alpha</math>的等级等于<math>\beta</math>的等级，称<math>\alpha</math>和<math>\beta</math>同等。
# 如果<math>\alpha</math>的等级小于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>低等。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#,m](n)</math>：
# 如果<math>[\#,m,n]</math>不存在，则<math>\alpha</math>的根为<math>n</math>。
# 如果<math>[\#,m,n]</math>存在，则<math>\alpha</math>的根为<math>m</math>。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z(n)</math>，则它的根为<math>n</math>。

对于序数<math>\alpha</math>：
# 如果它是复合序数，它形如<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>，则每个<math>\omega^{\alpha_k}</math>被它直接包含。
# 如果它是非零简单序数，它形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>，则每个<math>\alpha_k</math>均被它直接包含，<math>n</math>也被它直接包含。
# 如果它是0，没有任何序数被它直接包含。

<math>\alpha</math>直接包含<math>\beta</math>，记为<math>dInc(\beta,\alpha)</math>。

接下来是几个较为复杂的定义。

==== 末项，核与层数 ====
对于非零序数<math>\alpha</math>和简单序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的末项是以下两个序数<math>u</math>中较小者：
* <math>u</math>是满足“<math>u<s</math>，且存在序数<math>v</math>使<math>v+u=\alpha</math>”的最大序数。
* <math>u</math>是满足“<math>u</math>是简单序数且存在序数<math>w</math>，使得<math>\alpha=u\times{w}</math>”的最大序数。
* 如果上述两个规则中某条规则没有任何序数<math>u</math>能够满足，那么忽视那条规则。

<math>\alpha</math>关于<math>s</math>的末项记为<math>End(\alpha,s)</math>。特别地，<math>\alpha</math>关于<math>0</math>的末项与上文定义的末项等价，记为<math>End(\alpha)</math>。

对于序数<math>\alpha</math>，序数<math>s</math>，不小于-1的整数<math>k</math>，<math>\alpha</math>关于<math>s</math>的<math>k</math>层核，记为<math>Ker(\alpha,s,k)</math>，定义如下：
* <math>Ker(\alpha,s,-1)=\alpha</math>
* <math>Ker(0,s,k)=0</math>

以下假设<math>\alpha</math>非零，<math>k</math>是非负整数：
* <math>Ker(\alpha,s,k)=Ker(End(\alpha),End(s),k)</math>

以下假设<math>\alpha</math>和<math>s</math>都是非零简单序数，<math>k</math>是非负整数，<math>\alpha</math>形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>：
* <math>Ker(\alpha,s,0)=\psi_Z[End(\alpha_1,s),End(\alpha_2,s),\cdots,End(\alpha_m,s)](End(n,s))</math>
* <math>Ker(\alpha,s,k+1)=Ker(\psi_Z[Ker(\alpha_1,s,k),Ker(\alpha_2,s,k),\cdots,Ker(\alpha_m,s,k)](Ker(n,s,k)),s,0)</math>

对于序数<math>\alpha</math>，其层数是一个非负整数，记为<math>Lev(\alpha)</math>，定义如下：

* <math>Lev(0)=0</math>
* <math>Lev(\alpha)=max\{Lev(\beta)\mid{dInc(\beta,\alpha)}\}+1</math>

对于非零序数<math>\alpha</math>，序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的核记为<math>Ker(\alpha,s)</math>，它定义为<math>Ker(\alpha,s)=Ker(\alpha,s,Lev(\alpha))</math>。

特别地，<math>\alpha</math>的核记为<math>Ker(\alpha)</math>，它定义为<math>Ker(\alpha)=Ker(\alpha,0,Lev(\alpha))</math>。

=== 双元兼容 ===
对于序数<math>\alpha=\psi_Z[\#](n)</math>和<math>\beta=\psi_Z[\&](m)</math>，依次进行以下判定：
# 如果<math>\alpha>\beta</math>，则<math>[\alpha,\beta]</math>存在。
# 如果<math>\alpha</math>和<math>\beta</math>中至少有一个复合序数，则<math>[\alpha,\beta]</math>存在当且仅当<math>[End(\alpha),End(\beta)]</math>存在。
# 如果<math>\alpha=0</math>，则<math>[\alpha,\beta]</math>不存在。
# 当<math>\#=\&</math>时，<math>[\alpha,\beta]</math>存在当且仅当<math>[n,m]</math>存在；否则，如果存在序列<math>\%</math>使得<math>End(Endseq(\%))</math>与<math>End(Endseq(\#))</math>，<math>End(Endseq(\&))</math>之一相等，且存在序数<math>x</math>和序数<math>y</math>使得<math>\alpha=\psi_Z[\%](x)</math>且<math>\beta=\psi_Z[\%](y)</math>，则若<math>[x,y]</math>存在那么<math>[\alpha,\beta]</math>存在
# 如果<math>\beta\geq\psi_Z[\alpha](\alpha)</math>，则<math>[\alpha,\beta]</math>存在当且仅当<math>[\alpha,\beta</math>的根<math>]</math>存在；否则，如果存在简单序数<math>s</math>和不小于-1的整数<math>k</math>，使得<math>Ker(\beta,s,k)\geq\psi_Z[Ker(\alpha,s,k)](Ker(\alpha,s,k))</math>且不存在非零序数<math>x</math>和序列<math>\%</math>使得<math>Ker(\beta,s,k)=\psi_Z[Ker(\alpha,s,k)\times\omega,\%](Ker(\alpha,s,k)\times{x})</math>，则当<math>[\alpha,\beta</math>的根<math>]</math>存在时<math>[\alpha,\beta]</math>存在
# 如果存在两个序数<math>A</math>，<math>B</math>，<math>Ker(A)=Ker(\alpha)</math>，<math>Ker(B)=Ker(\beta)</math>，<math>A</math>属于<math>B</math>基本列，且<math>\alpha</math>比<math>\beta</math>高等，则<math>[\alpha,\beta]</math>存在
# 如果通过上述规则均无法说明<math>[\alpha,\beta]</math>存在，则<math>[\alpha,\beta]</math>不存在

=== 多元兼容 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，如果任取满足<math>k>j</math>的<math>\alpha=\alpha_j</math>，<math>\beta=\alpha_k</math>都有'''以下两个条件至少成立一个'''，则<math>[\#]</math>存在。

条件I：以下两个条件至少成立一个：
# <math>[\alpha,\beta]</math>存在
# <math>k<m</math>且存在满足<math>k>l</math>的<math>\gamma=\alpha_l</math>，使得<math>[\gamma,\beta]</math>不存在

条件II：对于任何满足<math>k<l</math>的<math>\gamma=\alpha_l</math>，存在简单序数<math>s</math>，不小于-1的整数<math>n</math>，使得以下两个条件同时成立：
# <math>[\beta,\gamma]</math>存在，且<math>Ker(\alpha,s,n)>Ker(\beta,s,n)</math>
#

''(好吧还没写完(因为看不懂)。除了这条规则(平移转移)，特殊规则以及各种优先级，还要补不少定义域限制，比如“m为序数或空”之类)''

== 直观解释 ==
FFFZ的前几条规则是
# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>

类似于BOCF的规则。为了提升强度，我们需要引入“兼容”的概念。

“兼容”就是中括号里的东西(有时也叫“伪链”，伪即Fake)，通过类似于“挡刀”的方式提升强度。举个例子：对<math>\psi_Z(n)</math>取极限，得到的并不是<math>\psi_Z(\omega)</math>，而是<math>\psi_Z[\omega](\omega)</math>，中括号内出现了挡刀的<math>\omega</math>。只有达到<math>\alpha\to\psi_Z[\omega](\alpha)</math>的第一个不动点时，才能得到<math>\psi_Z(\omega)</math>。

当然，我们并不局限于只把一个序数放进兼容里。兼容里可以有多个序数，举个例子：对<math>\psi_Z[\omega^2](\omega^2+n)</math>取极限，得到的并不是<math>\psi_Z[\omega^2](\omega^2+\omega)</math>，而是<math>\psi_Z[\omega^2,\omega^2+\omega](\omega^2+\omega)</math>。

从提升强度的角度考虑，我们当然希望设计一套规则，允许更多的兼容，从而最大限度地提升强度。但是，这样的规则并不是总是可行——考虑这样的规则：“任意一系列极限序数可以兼容”，那么我们有

<math>\psi_Z(\omega)\to\psi_Z[\omega](\psi_Z[\omega](\omega))\to\psi_Z[\omega](\psi_Z[\omega](2))\to\psi_Z[\omega](\omega\times{2})\to\psi_Z[\omega,\omega\times{2}](\psi_Z[\omega,\omega\times{2}](\omega\times{2}))\to\psi_Z[\omega,\omega\times{2}](\omega\times{3})\to\cdots</math>

无穷降链。

造成这种结果的原因在于，<math>[\omega,\omega\times{2},\omega\times{3},\cdots]</math>这些序数可以无限地兼容下去，形成'''无限兼容链'''。所以，我们希望的规则应该满足以下两个条件：

1. 允许兼容存在，以提升强度。

2. 不允许某些兼容存在，以避免无限兼容链。

由于实际分析和构造的需要，我们还有第三个条件：

3. 允许某些关键节点的特殊兼容存在。

基于上述的理念，作者给出了上文提到的那一系列规则。

''(未完待续。主要是补充一些概念的直观理解，比如“末项”之类的)''

== 衍生版本 ==
上文介绍的版本称为<math>\rm{Strong}</math>版本。除此之外，还有<math>\rm{Actual}</math>版本和<math>\rm{Weak}</math>版本，各版本区别如下：

=== <math>\rm{Actual}</math>版本 ===
''(等待补充)''

=== <math>\rm{Weak}</math>版本 ===
''(等待补充)''

== 分析 ==

[[分类:前沿]]
[[分类:记号]]

Fake Fake Fake Zeta

2025-07-26T09:07:55Z

Apocalypse：完成主要部分

'''Fake Fake Fake Z(FFFZ)'''，是由yahtzee于2022年提出，后续由国内的大数研究者夏夜星空完善的'''前沿记号'''。

== 定义 ==
'''注意：FFFZ的定义尚未完全确定，且有较为频繁的更改(大部分是修改一些小问题)。这里叙述最新一版(2025.7.26)的定义。'''

'''注意：部分概念的定义被修改为了等价版本。这些修改与原始文本之间是逻辑意义上的等价。'''

=== 主体规则 ===
FFFZ的合法表达式形如<math>\psi_Z[\#](n)</math>，极限基本列为<math>\{\psi_Z(0),\psi_Z(\psi_Z(0)),\psi_Z(\psi_Z(\psi_Z(0))),\cdots\}</math>。

# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>
# 如果<math>[\#,m,n]</math>存在，<math>\psi_Z[\#,m](n)[s]=f^s(n)</math>，其中<math>f(x)=\psi_Z[\#,m,n](x)</math>
# 如果<math>[\#,m,n]</math>不存在，<math>\psi_Z[\#,m](n)[s]=\psi_Z[\#,m](n[t+s])</math>。其中<math>t</math>定义如下：
* 如果<math>m\geq{n}</math>，那么<math>t=0</math>。
* 如果<math>m<n</math>，那么<math>t</math>是满足<math>n[t]\geq{m}</math>的最小非负整数。

=== 化简规则 ===
* <math>\psi_Z[\#,m](n)=\psi_Z[\#](n)</math>，<math>m>n</math>
* <math>\psi_Z[](n)=\psi_Z(n)</math>

为了判定<math>[\#]</math>的存在性，定义以下概念：

=== 名称解释 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，记它的末项为<math>Endseq(\#)=\alpha_m</math>。

对于序数<math>\alpha</math>，写出它的Cantor范式<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>。称<math>\omega^{\alpha_n}</math>为<math>\alpha</math>的末项。

如果<math>\alpha</math>等于它的末项，称<math>\alpha</math>为'''简单序数'''，否则为'''复合序数'''。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#](n)</math>：
# 如果<math>n</math>是后继序数，称<math>\alpha</math>是<math>+</math>型极限，或0级极限，等级为0。
# 如果<math>[\#,n]</math>不存在，称<math>\alpha</math>是<math>\omega</math>型极限，或1级极限，等级为1。
# 如果<math>[\#,n]</math>存在，称<math>\alpha</math>是<math>\varepsilon</math>型极限，或2级极限，等级为2。

对于两个非零简单序数<math>\alpha</math>和<math>\beta</math>：
# 如果<math>\alpha</math>的等级大于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>高等。
# 如果<math>\alpha</math>的等级等于<math>\beta</math>的等级，称<math>\alpha</math>和<math>\beta</math>同等。
# 如果<math>\alpha</math>的等级小于<math>\beta</math>的等级，称<math>\alpha</math>比<math>\beta</math>低等。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z[\#,m](n)</math>：
# 如果<math>[\#,m,n]</math>不存在，则<math>\alpha</math>的根为<math>n</math>。
# 如果<math>[\#,m,n]</math>存在，则<math>\alpha</math>的根为<math>m</math>。

对于非零简单序数<math>\alpha</math>，它形如<math>\alpha=\psi_Z(n)</math>，则它的根为<math>n</math>。

对于序数<math>\alpha</math>：
# 如果它是复合序数，它形如<math>\sum_{k=1}^{n} \omega^{\alpha_k}</math>，则每个<math>\omega^{\alpha_k}</math>被它直接包含。
# 如果它是非零简单序数，它形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>，则每个<math>\alpha_k</math>均被它直接包含，<math>n</math>也被它直接包含。
# 如果它是0，没有任何序数被它直接包含。

<math>\alpha</math>直接包含<math>\beta</math>，记为<math>dInc(\beta,\alpha)</math>。

接下来是几个较为复杂的定义。

==== 末项，核与层数 ====
对于非零序数<math>\alpha</math>和简单序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的末项是以下两个序数<math>u</math>中较小者：
* <math>u</math>是满足“<math>u<s</math>，且存在序数<math>v</math>使<math>v+u=\alpha</math>”的最大序数。
* <math>u</math>是满足“<math>u</math>是简单序数且存在序数<math>w</math>，使得<math>\alpha=u\times{w}</math>”的最大序数。
* 如果上述两个规则中某条规则没有任何序数<math>u</math>能够满足，那么忽视那条规则。

<math>\alpha</math>关于<math>s</math>的末项记为<math>End(\alpha,s)</math>。特别地，<math>\alpha</math>关于<math>0</math>的末项与上文定义的末项等价，记为<math>End(\alpha)</math>。

对于序数<math>\alpha</math>，序数<math>s</math>，不小于-1的整数<math>k</math>，<math>\alpha</math>关于<math>s</math>的<math>k</math>层核，记为<math>Ker(\alpha,s,k)</math>，定义如下：
* <math>Ker(\alpha,s,-1)=\alpha</math>
* <math>Ker(0,s,k)=0</math>

以下假设<math>\alpha</math>非零，<math>k</math>是非负整数：
* <math>Ker(\alpha,s,k)=Ker(End(\alpha),End(s),k)</math>

以下假设<math>\alpha</math>和<math>s</math>都是非零简单序数，<math>k</math>是非负整数，<math>\alpha</math>形如<math>\psi_Z[\alpha_1,\alpha_2,\cdots,\alpha_m](n)</math>：
* <math>Ker(\alpha,s,0)=\psi_Z[End(\alpha_1,s),End(\alpha_2,s),\cdots,End(\alpha_m,s)](End(n,s))</math>
* <math>Ker(\alpha,s,k+1)=Ker(\psi_Z[Ker(\alpha_1,s,k),Ker(\alpha_2,s,k),\cdots,Ker(\alpha_m,s,k)](Ker(n,s,k)),s,0)</math>

对于序数<math>\alpha</math>，其层数是一个非负整数，记为<math>Lev(\alpha)</math>，定义如下：

* <math>Lev(0)=0</math>
* <math>Lev(\alpha)=max\{Lev(\beta)\mid{dInc(\beta,\alpha)}\}+1</math>

对于非零序数<math>\alpha</math>，序数<math>s</math>，<math>\alpha</math>关于<math>s</math>的核记为<math>Ker(\alpha,s)</math>，它定义为<math>Ker(\alpha,s)=Ker(\alpha,s,Lev(\alpha))</math>。

特别地，<math>\alpha</math>的核记为<math>Ker(\alpha)</math>，它定义为<math>Ker(\alpha)=Ker(\alpha,0,Lev(\alpha))</math>。

=== 双元兼容 ===
对于序数<math>\alpha=\psi_Z[\#](n)</math>和<math>\beta=\psi_Z[\&](m)</math>，依次进行以下判定：
# 如果<math>\alpha>\beta</math>，则<math>[\alpha,\beta]</math>存在。
# 如果<math>\alpha</math>和<math>\beta</math>中至少有一个复合序数，则<math>[\alpha,\beta]</math>存在当且仅当<math>[End(\alpha),End(\beta)]</math>存在。
# 如果<math>\alpha=0</math>，则<math>[\alpha,\beta]</math>不存在。
# 当<math>\#=\&</math>时，<math>[\alpha,\beta]</math>存在当且仅当<math>[n,m]</math>存在；否则，如果存在序列<math>\%</math>使得<math>End(Endseq(\%))</math>与<math>End(Endseq(\#))</math>，<math>End(Endseq(\&))</math>之一相等，且存在序数<math>x</math>和序数<math>y</math>使得<math>\alpha=\psi_Z[\%](x)</math>且<math>\beta=\psi_Z[\%](y)</math>，则若<math>[x,y]</math>存在那么<math>[\alpha,\beta]</math>存在
# 如果<math>\beta\geq\psi_Z[\alpha](\alpha)</math>，则<math>[\alpha,\beta]</math>存在当且仅当<math>[\alpha,\beta</math>的根<math>]</math>存在；否则，如果存在简单序数<math>s</math>和不小于-1的整数<math>k</math>，使得<math>Ker(\beta,s,k)\geq\psi_Z[Ker(\alpha,s,k)](Ker(\alpha,s,k))</math>且不存在非零序数<math>x</math>和序列<math>\%</math>使得<math>Ker(\beta,s,k)=\psi_Z[Ker(\alpha,s,k)\times\omega,\%](Ker(\alpha,s,k)\times{x})</math>，则当<math>[\alpha,\beta</math>的根<math>]</math>存在时<math>[\alpha,\beta]</math>存在
# 如果存在两个序数<math>A</math>，<math>B</math>，<math>Ker(A)=Ker(\alpha)</math>，<math>Ker(B)=Ker(\beta)</math>，<math>A</math>属于<math>B</math>基本列，且<math>\alpha</math>比<math>\beta</math>高等，则<math>[\alpha,\beta]</math>存在
# 如果通过上述规则均无法说明<math>[\alpha,\beta]</math>存在，则<math>[\alpha,\beta]</math>不存在

=== 多元兼容 ===
对于序列<math>\#=\alpha_1,\alpha_2,\cdots,\alpha_m</math>，如果任取满足<math>k>j</math>的<math>\alpha=\alpha_j</math>，<math>\beta=\alpha_k</math>都有'''以下两个条件至少成立一个'''，则<math>[\#]</math>存在。

条件I：以下两个条件至少成立一个：
# <math>[\alpha,\beta]</math>存在
# <math>k<m</math>且存在满足<math>k>l</math>的<math>\gamma=\alpha_l</math>，使得<math>[\gamma,\beta]</math>不存在

条件II：对于任何满足<math>k<l</math>的<math>\gamma=\alpha_l</math>，存在简单<math>s</math>，不小于-1的整数<math>n</math>，使得以下两个条件同时成立：
# <math>[\beta,\gamma]</math>存在，且<math>Ker(\alpha,s,n)>Ker(\beta,s,n)</math>
#

''(好吧还没写完(因为看不懂)。除了这条规则(平移转移)，特殊规则以及各种优先级，还要补不少定义域限制，比如“m为序数或空”之类)''

== 直观解释 ==
FFFZ的前几条规则是
# <math>\psi_Z(0)[s]=1</math>
# <math>\psi_Z[\#](n+1)[s]=\psi_Z[\#](n)\times{s}</math>

类似于BOCF的规则。为了提升强度，我们需要引入“兼容”的概念。

“兼容”就是中括号里的东西(有时也叫“伪链”，伪即Fake)，通过类似于“挡刀”的方式提升强度。举个例子：对<math>\psi_Z(n)</math>取极限，得到的并不是<math>\psi_Z(\omega)</math>，而是<math>\psi_Z[\omega](\omega)</math>，中括号内出现了挡刀的<math>\omega</math>。只有达到<math>\alpha\to\psi_Z[\omega](\alpha)</math>的第一个不动点时，才能得到<math>\psi_Z(\omega)</math>。

当然，我们并不局限于只把一个序数放进兼容里。兼容里可以有多个序数，举个例子：对<math>\psi_Z[\omega^2](\omega^2+n)</math>取极限，得到的并不是<math>\psi_Z[\omega^2](\omega^2+\omega)</math>，而是<math>\psi_Z[\omega^2,\omega^2+\omega](\omega^2+\omega)</math>。

从提升强度的角度考虑，我们当然希望设计一套规则，允许更多的兼容，从而最大限度地提升强度。但是，这样的规则并不是总是可行——考虑这样的规则：“任意一系列极限序数可以兼容”，那么我们有

<math>\psi_Z(\omega)\to\psi_Z[\omega](\psi_Z[\omega](\omega))\to\psi_Z[\omega](\psi_Z[\omega](2))\to\psi_Z[\omega](\omega\times{2})\to\psi_Z[\omega,\omega\times{2}](\psi_Z[\omega,\omega\times{2}](\omega\times{2}))\to\psi_Z[\omega,\omega\times{2}](\omega\times{3})\to\cdots</math>

无穷降链。

造成这种结果的原因在于，<math>[\omega,\omega\times{2},\omega\times{3},\cdots]</math>这些序数可以无限地兼容下去，形成'''无限兼容链'''。所以，我们希望的规则应该满足以下两个条件：

1. 允许兼容存在，以提升强度。

2. 不允许某些兼容存在，以避免无限兼容链。

由于实际分析和构造的需要，我们还有第三个条件：

3. 允许某些关键节点的特殊兼容存在。

基于上述的理念，作者给出了上文提到的那一系列规则。

''(未完待续。主要是补充一些概念的直观理解，比如“末项”之类的)''

== 衍生版本 ==
上文介绍的版本称为<math>\rm{Strong}</math>版本。除此之外，还有<math>\rm{Actual}</math>版本和<math>\rm{Weak}</math>版本，各班本区别如下：

=== <math>\rm{Actual}</math>版本 ===
''(等待补充)''

=== <math>\rm{Weak}</math>版本 ===
''(等待补充)''

== 分析 ==

[[分类:前沿]]
[[分类:记号]]

Y序列

2025-07-21T13:41:54Z

Apocalypse：小幅重写定义&增加山脉图部分

'''Y序列'''，一般指'''1-Y'''，一种[[Beklemishev's Worm|Worm]]型序数记号。

== 定义 ==

=== 合法表达式 ===
一个合法的 1-Y 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 1-Y 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
1-Y的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 1-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。'''与0-Y不同的是：
* 行标现在可以是一个超限序数，例如第<math>\omega</math>行。
* 一些项现在可以不赋予任何数作为取值，这些项称为空项，记作<math>\varnothing</math>。'''
第<math>\alpha</math>行第<math>j</math>列的项记为<math>x_{\alpha,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 后继序数行的父项 & 阶差项 ====
对于后继序数<math>\alpha+1</math>和非空项<math>x_{\alpha+1,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧非空项<math>x_{\alpha+1,k}</math>：

* <math>k<j</math>且<math>x_{\alpha+1,k}<x_{\alpha+1,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于第0行的项<math>x_{0,j}</math>，它的父项是与它位于同一行，且同时满足<math>k<j</math>和<math>x_{0,k}<x_{0,j}</math>的最右侧项<math>x_{0,k}</math>。

如果满足上述条件的项不存在，那么<math>x_{\alpha+1,j}</math>(或者<math>x_{0,j}</math>)的父项不存在。特别地，等于1的项的父项不存在。

对于任何序数<math>\alpha</math>，项<math>x_{\alpha,j}</math>：
* 如果它有父项<math>x_{\alpha,k}</math>，则它的阶差项为<math>x_{\alpha+1,j}=x_{\alpha,j}-x_{\alpha,k}</math>。
* 如果它没有父项，或者为空项，它的阶差项为<math>x_{\alpha,j}=\varnothing</math>。

由于第<math>\alpha</math>行的项的阶差项构成了第<math>\alpha+1</math>行，称第<math>\alpha+1</math>行的序列是第<math>\alpha</math>行的序列的'''阶差序列'''。

==== 极限序数行的父项 & 提取 ====
上述定义只给出了后继序数行的项的取值和父项关系。接下来给出极限序数的情形：

设极限序数<math>\alpha=\beta+\omega<\omega^2</math>，<math>\beta</math>为极限序数。则定义项<math>x_{\alpha,j}</math>如下：

取出最大的非负整数<math>p</math>使得<math>x_{\beta+p,j}</math>不为空项，则<math>x_{\alpha,j}=x_{\beta+p,j}</math>。这些项<math>x_{\beta+p,j}</math>称为主项。

对大于1的项<math>x_{\alpha,j}</math>定义如下概念：
# 设<math>x_{\alpha,j}=x_{\beta+p,j}</math>，令<math>a=j</math>。
# 设<math>x_{\beta+p-1,a}</math>的父项为<math>x_{\beta+p-1,k}</math>。如果<math>x_{\beta+p-1,k}</math>是主项，或者<math>x_{\beta+p,k}</math>是主项，称<math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟父项。
# 否则令<math>a=k</math>并回到第2步，直到找到某个主项，设其列标是<math>l</math>，称<math>x_{\alpha,l}</math>是<math>x_{\alpha,j}</math>的拟父项。

对于极限序数<math>\alpha</math>和大于1的项<math>x_{\alpha,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧项<math>x_{\alpha,k}</math>：

* <math>k<j</math>且<math>x_{\alpha,k}<x_{\alpha,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟祖先项。

这里“拟祖先项”的定义是：一个元素自己，以及它的拟父项、拟父项的拟父项......共同构成它的拟祖先项。

如果满足上述条件的项不存在，那么<math>x_{\alpha,j}</math>的父项不存在。另外，等于1的项的父项不存在。

以上定义项<math>x_{\alpha,j}</math>时，将所有位于<math>\beta</math>到<math>\beta+\omega</math>之间的行中每一列的最上方非空项取了出来，并“提”到了<math>\alpha=\beta+\omega</math>行(还保留了其下的一些父项关系)，这就是'''提取(Extraction)'''的含义。

''注：此处的“主项”，“拟父项/拟祖先项”是编者引入的等价的临时定义。在主流的定义与教程中，通常使用山脉图(见下文)定义此部分内容。''

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{\alpha,n}</math>，它的父项设为<math>x_{\alpha,r}</math>。如果在计算到某行(第<math>\gamma</math>行)时有<math>x_{\gamma,n}-x_{\gamma,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''。

以上给出了 1-Y 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述1-Y的展开规则或者直观理解部分定义，需要用到'''山脉图'''的辅助。

1-Y的山脉图作图难度略高于[[0-Y]]。对于 1-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则逐行向上求出各项，直到某次提取的所有主项全为1，不进行这次提取。

接下来，对于第后继序数<math>\alpha+1</math>行，进行如下操作：

取出所有非空项<math>x_{\alpha+1,j}</math>。对于每个<math>x_{\alpha,j}</math>，用竖直线段连接<math>x_{\alpha+1,j}</math>的下端与<math>x_{\alpha,j}</math>的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math>称为它的端点。

设<math>x_{\alpha,j}</math>有父项<math>x_{\alpha,k}</math>，用斜线段连接<math>x_{\alpha+1,j}</math>的下端与<math>x_{\alpha,k}</math>的上端。这些斜线段称为'''左腿'''，<math>x_{\alpha,k}</math>称为它的端点。

接下来，对于第极限序数<math>\alpha=\beta+\omega</math>行，进行如下操作：

用虚线分别连接所有项<math>x_{\alpha,j}</math>的下端，和它们对应的主项<math>x_{\beta+p,j}</math>的上端。

对所有行各执行一次上述操作，就得到了<math>(a_1,a_2,\cdots,a_n)</math>的山脉图。

注意：有些情况下，山脉图只包含一行，即第0行。

''(待补充附有配图的1-Y山脉图绘制例子,以及绘制1-Y山脉图的网站(有吗),以及极限序数行父项关系的直观理解)''

== 展开 ==
1-Y的展开难度远高于[[0-Y]]。

''(好吧我不会写了,等待更新)''

== 枚举 ==
''(开摆!)''

== n-Y序列 ==
通过某种方式，我们可以把1-Y前面的参数1扩展到任意大的自然数<math>n</math>。详细信息请参考[[ω-Y]]页面。

[[分类:记号]]

Y序列

2025-07-20T12:28:05Z

Apocalypse：1-Y定义(不包括山脉图)

'''Y序列'''，又称'''1-Y'''，是一种[[Beklemishev's Worm|Worm]]型序数记号。

== 定义 ==

=== 合法表达式 ===
一个合法的 1-Y 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 1-Y 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
1-Y的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 1-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。'''与0-Y不同的是，行标现在可以是一个超限序数，例如第<math>\omega</math>行。'''第<math>\alpha</math>行第<math>j</math>列的项记为<math>x_{\alpha,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 后继序数行的父项 & 阶差项 ====
对于后继序数<math>\alpha+1</math>和项<math>x_{\alpha+1,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧项<math>x_{\alpha+1,k}</math>：

* <math>k<j</math>且<math>x_{\alpha+1,k}<x_{\alpha+1,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于第0行的项<math>x_{0,j}</math>，它的父项是与它位于同一行，且同时满足<math>k<j</math>和<math>x_{0,k}<x_{0,j}</math>的最右侧项<math>x_{0,k}</math>。

如果满足上述条件的项不存在，那么<math>x_{\alpha+1,j}</math>(或者<math>x_{0,j}</math>)的父项不存在。特别地，等于1的项的父项不存在。

对于任何序数<math>\alpha</math>，项<math>x_{\alpha,j}</math>，如果它有父项<math>x_{\alpha,k}</math>，则它的阶差项为<math>x_{\alpha+1,j}=x_{\alpha,j}-x_{\alpha,k}</math>。否则它的阶差项不存在。

由于第<math>\alpha</math>行的项的阶差项构成了第<math>\alpha+1</math>行，称第<math>\alpha+1</math>行的序列是第<math>\alpha</math>行的序列的'''阶差序列'''。

==== 极限序数行的父项 & 提取 ====
上述定义只给出了后继序数行的项的取值和父项关系。接下来给出极限序数的情形：

设极限序数<math>\alpha=\beta+\omega</math>，<math>\beta</math>为极限序数。则定义项<math>x_{\alpha,j}</math>如下：

取出最大的非负整数p使得<math>x_{\beta+p,j}</math>有定义，则<math>x_{\alpha,j}=x_{\beta+p,j}</math>。这些项<math>x_{\beta+p,j}</math>称为大项。

对大于1的项<math>x_{\alpha,j}</math>定义如下概念：
* 设<math>x_{\alpha,j}=x_{\beta+p,j}</math>，<math>x_{\beta+p-1,j}</math>的父项为<math>x_{\beta+p-1,k}</math>。
* 如果<math>x_{\beta+p-1,k}</math>是大项，或者<math>x_{\beta+p,k}</math>是大项，称<math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟父项。
* 否则将<math>x_{\beta+p-1,k}</math>换为其父项并重复上一条规则，直到找到某个大项，设其列标是<math>l</math>，称<math>x_{\alpha,l}</math>是<math>x_{\alpha,j}</math>的拟父项。

对于极限序数<math>\alpha</math>和大于1的项<math>x_{\alpha,j}</math>，它的父项是与它位于同一行，且满足以下条件的最右侧项<math>x_{\alpha,k}</math>：

* <math>k<j</math>且<math>x_{\alpha,k}<x_{\alpha,j}</math>。
* <math>x_{\alpha,k}</math>是<math>x_{\alpha,j}</math>的拟祖先项。

这里“拟祖先项”的定义是：一个元素自己，以及它的拟父项、拟父项的拟父项......共同构成它的拟祖先项。

如果满足上述条件的项不存在，那么<math>x_{\alpha,j}</math>的父项不存在。另外，等于1的项的父项不存在。

以上定义项<math>x_{\alpha,j}</math>时，将所有位于<math>\beta</math>到<math>\beta+\omega</math>之间的行中每一列的最上方项取了出来，并“提”到了<math>\alpha=\beta+\omega</math>行(还保留了其下的一些父项关系)，这就是'''提取(Extraction)'''的含义。

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{\alpha,n}</math>，它的父项设为<math>x_{\alpha,r}</math>。如果在计算到某行(第<math>\gamma</math>行)时有<math>x_{\gamma,n}-x_{\gamma,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''。

以上给出了 1-Y 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

Googology 梗百科

2025-07-18T22:37:18Z

Apocalypse：

本页面收录了一些中文ggg圈的梗。

== 一、聊天记录类 ==

=== 1.定义没有，牛B吹爆 ===
起因是3184说了句“来点小小的链节余项震撼”，后被hypcos回复“定义没有，牛B吹爆”
[[文件:12345B67.jpg|左|缩略图|截图日期：2024年8月9日]]

因为其过于经典而被广为流传。

后来还衍生出了多种版本，如“1234，5B67”和“□□□□，□□□□”，“分析没有，牛B吹爆”等

=== 2.XX给你打了 ===
出自于涵对hypcos的回复“坦克给你打了”
[[文件:Tank.jpg|左|缩略图|--]]
其中“坦克”指的是[[LVO]]，这个名词来源于文件《大数级别段位》（一个数字量级表）中的“掌控者坦克”。另一个较为出名的是“邢天战甲”，被用于指代[[BO]]。

这个梗中的“坦克”可以被换成任意词，被用于调侃性地表达两个事物间的比较。

此外，受这段聊天记录影响，有一些人在讨论部分内容时也常常使用“我倾向于”表达自己的观点。

详细信息可以参考B站用户3183丶4139的这期视频<ref>【坦克给你打了是什么梗【(伪)梗指南】-哔哩哔哩】 https://b23.tv/ULKDxxw</ref>

== 二、错字类 ==

== 参考资料 ==
<references />

0-Y

2025-07-18T21:53:21Z

Apocalypse：

'''0-Y'''是一种[[Beklemishev's Worm|Worm]]型序数记号，它是[[初等序列系统|PrSS]]的一种扩展。

== 定义 ==

=== 合法表达式 ===
一个合法的 0-Y 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 0-Y 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
0-Y的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。第<math>i</math>行第<math>j</math>列的项记为<math>x_{i,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 父项与阶差项 ====
等于1的项没有父项。对于大于1的项<math>x_{i,j}</math>，它的父项与它位于同一行，且是满足以下条件的最右侧项<math>x_{i,k}</math>：

* <math>k<j</math>且<math>x_{i,k}<x_{i,j}</math>。
* 如果<math>i>0</math>，还要求<math>x_{i-1,k}</math>是<math>x_{i-1,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于<math>x_{i,j}</math>，如果它有父项<math>x_{i,k}</math>，则它的阶差项为<math>x_{i+1,j}=x_{i,j}-x_{i,k}</math>；如果<math>x_{i,j}=1</math>，则它的阶差项<math>x_{i+1,j}=1</math>。

由于第<math>i</math>行的项的阶差项构成了第<math>i+1</math>行，称第<math>i+1</math>行的序列是第<math>i</math>行的序列的'''阶差序列'''。

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{i,n}</math>，它的父项设为<math>x_{i,r}</math>。如果在计算到某行(第<math>p</math>行)时有<math>x_{p,n}-x_{p,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''，并且不再计算第<math>p+1</math>行及之后的行。

以上给出了 0-Y 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述0-Y的展开规则，需要用到'''山脉图'''的辅助。对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则画出第0到<math>p</math>行。现在你有了一个<math>p\times{n}</math>的“矩阵”(第0至第<math>p</math>行，第1至第<math>n</math>列)，接下来，对于第<math>i</math>行，<math>0\leq{i}\leq{p-1}</math>进行如下操作：

对于每个<math>x_{i,j}</math>，用竖直线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,j}</math>的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math>称为它的端点。

对于每个大于1的<math>x_{i,j}</math>，设<math>x_{i,j}</math>有父项<math>x_{i,k}</math>，用斜线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,k}</math>的上端。这些斜线段称为'''左腿'''，<math>x_{i,k}</math>称为它的端点。

对第1到第<math>p</math>行各执行一次上述操作，就得到了<math>(a_1,a_2,\cdots,a_n)</math>的山脉图。

注意：有些情况下，山脉图只包含一行，即第0行。

注：由于山脉图的某一行只和其下的项有关，你也可以在逐行往上填写阶差序列的同时画出山脉图。许多常见的0-Y教程都采用这个方法。

''(待补充附有配图的0-Y山脉图绘制例子,以及绘制0-Y山脉图的网站(有吗))''

== 展开 ==
对于 0-Y 的一个表达式<math>(a_1,a_2,\cdots,a_n)</math>：

* 如果它是零表达式，它对应序数0。
* 如果它是后继表达式，它对应<math>(a_1,a_2,\cdots,a_{n-1})</math>的后继。
* 如果它是极限表达式，它的基本列第<math>q</math>项如下确定：

# 作出<math>p\times{n}</math>的山脉图。称位于根列右侧的结构(包括阶差项和其对应的山脉图中的左右腿，不包括根列)为'''坏部'''，其余为'''好部'''。
# 删除坏部中第<math>p</math>行以下的所有项，并将<math>x_{p,n}</math>减1。
# 接下来，保留山脉图的好部不动，将坏部平移并复制在山脉图末尾，复制<math>q-1</math>次。“坏部平移”是指左右腿及端点同时平移。
# 特别地，如果某一条左腿的端点位于根列左侧，复制时左腿的端点不向右平移。
# 接下来，你得到了根列右侧的一系列山脉图和第<math>p</math>行的一系列项。从根列右侧开始，从上到下，每一行从左到右，按照以下方式填入正整数：对于某个位置，向上通过右腿移动到值为<math>x</math>的项，然后向左下通过左腿移动到值为<math>y</math>的项，则回到初始位置并填上<math>x+y</math>。
# 最后得到的第0行的序列，就是<math>(a_1,a_2,\cdots,a_n)</math>展开的基本列第<math>q-1</math>项。

0-Y的极限基本列是<math>\{(1,2),(1,3),(1,4),\cdots\}</math>，从这个基本列中元素开始取前驱或取基本列所能得到的表达式是 0-Y 的标准式。

''(待补充附有配图的0-Y展开例子,比如Y(1,4,6,4)和Y(1,4,6,3,7,9,7),后者有不平移的端点)''

== 枚举 ==
我们使用 [[Bashicu矩阵|BMS]] 对 0-Y 进行简单分析(左边是BMS，右边是0-Y)。

<math>(0)=1</math>

<math>(0)(1)=1,2</math>

<math>(0)(1)(1)=1,2,2</math>

<math>(0)(1)(2)=1,2,3</math>

<math>(0)(1)(2)(3)=1,2,3,4</math>

<math>(0)(1,1)=1,3</math>

<math>(0)(1,1)(1,0)=1,3,2</math>

<math>(0)(1,1)(1,0)(2,1)=1,3,2,4</math>

<math>(0)(1,1)(1,1)=1,3,3</math>

<math>(0)(1,1)(2,0)=1,3,4</math>

<math>(0)(1,1)(2,0)(3,1)=1,3,4,6</math>

<math>(0)(1,1)(2,1)=1,3,5</math>

<math>(0)(1,1)(2,1)(3,1)=1,3,5,7</math>

<math>(0)(1,1)(2,2)=1,3,6</math>

<math>(0)(1,1)(2,2)(3,3)=1,3,6,10</math>

<math>(0)(1,1,1)=1,4</math>

<math>(0)(1,1,1)(1,0,0)(2,1,1)=1,4,2,5</math>

<math>(0)(1,1,1)(1,1,0)=1,4,3</math>

<math>(0)(1,1,1)(1,1,0)(2,2,1)=1,4,3,7</math>

<math>(0)(1,1,1)(1,1,1)=1,4,4</math>

<math>(0)(1,1,1)(2,0,0)=1,4,5</math>

<math>(0)(1,1,1)(2,1,0)=1,4,6</math>

<math>(0)(1,1,1)(2,1,0)(1,1,1)=1,4,6,4</math>

<math>(0)(1,1,1)(2,1,0)(3,1,0)=1,4,6,8</math>

<math>(0)(1,1,1)(2,1,0)(3,2,1)=1,4,6,10</math>

<math>(0)(1,1,1)(2,1,1)=1,4,7</math>

<math>(0)(1,1,1)(2,1,1)(3,1,1)=1,4,7,10</math>

<math>(0)(1,1,1)(2,2,0)=1,4,8</math>

<math>(0)(1,1,1)(2,2,1)=1,4,9</math>

<math>(0)(1,1,1)(2,2,2)=1,4,10</math>

<math>(0)(1,1,1)(2,2,2)(3,3,3)=1,4,10,20</math>

<math>(0)(1,1,1,1)=1,5</math>

<math>(0)(1,1,1,1,1)=1,6</math>

<math>\cdots</math>

两者极限相等。

== 与[[Bashicu矩阵|BMS]]的互译 ==
事实上，0-Y与[[Bashicu矩阵|BMS]]的标准式之间有十分简单的互译关系。

对于一个 0-Y 标准表达式，作出其山脉图，但不考虑末列的影响，而是无限地逐行向上作出阶差序列，直到得到的序列全为1。

现在你有了一个<math>t\times{n}</math>的山脉图，行标为0到<math>t</math>，列标为1到<math>n</math>。

定义<math>b_{i,j}</math>如下：

* <math>x_{i,j}=1</math>时<math>b_{i,j}=0</math>。
*否则设<math>x_{i,j}</math>的父项为<math>x_{i,k}</math>，令<math>b_{i,j}=b_{i,k}+1</math>。

最后得到的矩阵<math>(b_{i,j})</math>删去最顶上全为0的行，并以水平线为轴镜像，即可得到等价的BMS。

对于一个BMS标准式<math>(d_{i,j})</math>(第1至第<math>t</math>行，第1至第<math>n</math>列)，定义<math>e_{i,j}</math>如下：

* <math>d_{i,j}=0</math>时<math>e_{i,j}=1</math>。
* 否则设<math>d_{i,j}</math>的父项为<math>d_{i,k}</math>，令<math>e_{i,j}=e_{i,k}+e_{i+1,j}</math>。如果<math>i=t</math>，我们规定<math>e_{i+1,j}=1</math>。

最后取出<math>f_k=e_{1,k}</math>，即为等价的0-Y序列。

然而，尽管目前已有的分析均支持以上结论，目前对此尚未有严格的证明。

== 与[[Y序列]]的关系 ==
0-Y虽然名字里带有'''Y'''，但它与[[Y序列]]的内核有较大差异。

历史上，0-Y的出现晚于通常的Y序列，而且强度也远低于Y序列。事实上，0-Y是仿照BMS制作出来的。

[[分类:记号]]

模型

2025-07-18T02:28:16Z

Apocalypse：

一个给定语言<math>\lambda</math>的模型是一个对<math>(A,I)</math>，其中<math>A</math>为全域/宇宙，<math>I</math>为<math>A</math>上的解释函数，负责把<math>\lambda</math>中的符号映射到A中合适的关系，函数，常元。通常我们将模型写为以下形式

<math>\alpha=(A,P^\alpha,\cdots,F^\alpha,\cdots,c^\alpha)</math>

在中文语境中，语言的模型也被称为数学结构。

我们定义，一个数学结构<math>A</math>满足某个公式<math>\phi(a,b,\cdots)</math>，

当且仅当<math>\phi(a^A,b^B,\cdots)</math>在<math>A</math>中成立。

一个语句集<math>\Sigma</math>的模型，是一个数学结构<math>A</math>，使得其满足这个语句集中的任意一条语句。

== 模型的同构 ==

我们称两个模型<math>A=(\alpha,P^A,\cdots,F^A,\cdots,c^A)</math>，<math>B=(\beta,P^B,\cdots,F^B,\cdots,c^B)</math>是同构的，当且仅当存在一个<math>A</math>到<math>B</math>的一对一函数<math>f</math>使得以下四点成立：

* <math>P^A(x_1,x_2,x_3,\cdots)</math>当且仅当<math>P^B(f(x_1),f(x_2),f(x_3),\cdots)</math>(<math>P</math>为某个<math>n</math>元关系且<math>P^A</math>映射到的对象是<math>P^B</math>)

* <math>f(F^A(x_1,x_2,x_3,\cdots))=F^B(f(x_1),f(x_2),f(x_3),\cdots)</math>

* <math>f(c^A)=c^B</math>

* <math>A\models\phi(a_1,a_2,\cdots)</math>当且仅当<math>B\models\phi(f(a_1),f(a_2),\cdots)</math>

== 子模型 ==
我们称一个模型<math>A=(\alpha,P^A,\cdots,F^A,\cdots,c^A)</math>是模型<math>B=(\beta,P^B,\cdots,F^B,\cdots,c^B)</math>的子模型，当且仅当：

<math>\alpha\subset\beta</math>，<math>P^A\subset{P^B}</math>，<math>F^A\subset{F^B}</math>，<math>c^B\in{A}</math>且<math>A</math>在任意<math>A</math>上函数下封闭。

一个从<math>B</math>到<math>A</math>的嵌入是一个<math>B</math>和<math>A</math>的子模型<math>B_1</math>之间的同构关系。

一个<math>A</math>的子模型<math>B</math>是<math>A</math>的'''初等子模型'''，当且仅当对于任何<math>B</math>中的元素<math>(b_1,b_2,b_3,\cdots)</math>，

<math>B\models\phi(b_1,b_2,b_3,\cdots)</math>当且仅当<math>A\models\phi(b_1,b_2,b_3,\cdots)</math>。

两个模型是'''基本等价'''的，当且仅当它们满足同样的语句(无自由变量的命题)。

模型

2025-07-18T01:43:05Z

Apocalypse：加入公式

增长层级

2025-07-18T01:15:20Z

Apocalypse：/* 警告 */

'''增长层级(Growing Hierarchy,GH)'''是一种函数族<math>f:\rm Ord\rightarrow\mathbb{N}\rightarrow\mathbb{N}</math>，对于每个[[序数]]<math>\alpha</math>，<math>f_{\alpha}</math>是一个从自然数到自然数的函数。

不同[[增长率]]的函数能和它们建立起大致的对应关系。因此，增长层级常被用于分析函数的增长率。

常用的增长层级有 4 种，分别为 FGH、MGH、HH 和 SGH。其中最常用的是 FGH。

=== 定义 ===
在这里，<math>f^n(\cdot)</math> 代表对函数 <math>f(\cdot)</math> 的 <math>n</math> 次迭代；其中 <math>\alpha[n]</math> 表示[[序数#极限序数|极限序数]] <math>\alpha</math> 的[[基本列]]第 <math>n</math> 项。所有的典型增长层级都是由超限递归定义的。

这里由于增长层级都针对递归序数，令 <math>\bold{Rec}</math> 为递归序数集合，<math>\bold{Rec}_\text{lim}</math> 为极限（递归）序数集合。

==== 快速增长层级 ====
快速增长层级（Fast Growing Hierarchy，FGH）

* <math>\forall n\in\mathbb{N},f_0(n)=n+1</math>
* <math>\forall\alpha\in\bold{Rec},n\in\mathbb{N},f_{\alpha+1}(n)=f^n_\alpha(n)</math>
* <math>\forall\alpha\in\bold{Rec}_\text{lim},n\in\mathbb{N},f_\alpha(n)=f_{\alpha[n]}(n)</math>

==== 中速增长层级 ====
中速增长层级（Middle Growing Hierarchy，MGH）

* <math>\forall n\in\mathbb{N},m_0(n)=n+1</math>
* <math>\forall\alpha\in\bold{Rec},n\in\mathbb{N},m_{\alpha+1}(n)=m_\alpha(m_\alpha(n))</math>
* <math>\forall\alpha\in\bold{Rec}_\text{lim},n\in\mathbb{N},m_\alpha(n)=m_{\alpha[n]}(n)</math>

==== 哈代层级 ====
哈代层级（Hardy Hierarchy，HH）

* <math>\forall n\in\mathbb{N},H_0(n)=n</math>
* <math>\forall\alpha\in\bold{Rec},n\in\mathbb{N},H_{\alpha+1}(n)=H_\alpha(n+1)</math>
* <math>\forall\alpha\in\bold{Rec}_\text{lim},n\in\mathbb{N},H_\alpha(n)=H_{\alpha[n]}(n)</math>

==== 慢速增长层级 ====
慢速增长层级（Slow Growing Hierarchy，SGH）

* <math>\forall n\in\mathbb{N},g_0(n)=0</math>
* <math>\forall\alpha\in\bold{Rec},n\in\mathbb{N},g_{\alpha+1}(n)=g_\alpha(n)+1</math>
* <math>\forall\alpha\in\bold{Rec}_\text{lim},n\in\mathbb{N},g_\alpha(n)=g_{\alpha[n]}(n)</math>

=== 在大数数学中的应用 ===
我们知道，大数数学的目的是造出越来越巨大的自然数。为了这个目标，我们需要构造出增长的越来越快的大数函数。实际上，我们有以下两种办法来做到这件事情，即'''迭代'''和'''对角化'''：

* 迭代，即对于已有函数 <math>f(x)</math>，我们构造出函数 <math>g(x)</math> 增长速度快于 <math>f(x)</math>。注意到迭代的方法显然不止一种。比方说，让 <math>g(x)=\underbrace{f(f(f(\cdots(x)\cdots)))}_{x\text{ 层}}</math>，这是一种迭代方法。还可以让 <math>g(x)=f(x+1)</math> 等等。
* 对角化，即对于已有的 <math>\omega</math> 个增长速度递增的函数，我们按照增长速度由小到大排序为 <math>f_1(x),f_2(x),f_3(x),\cdots</math>，我们构造出函数 <math>g(x)=f_x(x)</math>。注意到 <math>g(x)</math> 的增长速度快于任意的<math>f_n(x)</math>。

因此，我们只需要从一个最初的函数出发，通过不断地迭代和对角化，就可以得到越来越快的函数.

现在让我们考察[[序数]]，会发现，序数存在以下两个性质：

* 对任意序数 α，α 的后继依然是一个序数且大于 α。
* 对 ω 个递增序数构成的序列 S 来说，存在一个 β 是序数且满足 β 是 S 的上确界（上界要求大于等于内部所有元素，上确界是最小上界）。或者说，这里的S是β的一条[[基本列]]。

因此，我们可以从 0 出发，通过不断地取后继和取上确界，我们可以得到越来越大的序数.

我们会发现，构造大数函数的方法和序数的性质之间存在某种意义的对应。那么，我们可不可以直接根据序数，生成大数函数呢？答案是可以的。我们需要完成以下三件事：

* 对序数 0，它要和一个最基础的函数对应。
* 对一个[[序数#序数的后继|后继序数]] α'（α 的后继），我们需要找到 α，然后把 α 对应的函数进行迭代，所得到的新函数就是 α' 对应的函数。
* 对一个[[序数#极限序数|极限序数]] β，我们需要找到 β 的基本列，然后把基本列所有元素对应的函数进行对角化，得到的新函数就是 β 对应的函数。

但注意到这里还有一个问题：一个极限序数的基本列不止一种，那么，我们如何确定应该选取哪一条基本列呢？这个时候就需要[[序数记号]]出马了。序数记号为其极限之下的每个序数指定了唯一的标准基本列。

有了序数记号之后，我们就可以放心的运用对应关系，直接把序数转换成大数函数了。把序数转换成大数函数的工具就是增长层级。根据迭代的方法不同，增长层级也有很多种，包含 FGH,HH,MGH,SGH 等等。

=== 不同增长层级的对比<ref><nowiki>https://zhuanlan.zhihu.com/p/720580794</nowiki></ref> ===
MGH 相比 FGH，下标 +1 的方式仅由“嵌套 n（自变量）层”变为“嵌套 2 层”。因此，MGH 的下标每加一次 <math>\omega</math>，就能将函数嵌套 <math>2^n</math> 层，实现略大于 FGH 中下标 +1 的作用。

对于使得 <math>m_{\alpha}(n)=f_{\beta}(n)</math> 的 <math>\alpha</math> 和 <math>\beta</math>，我们有

<math>m_{\alpha+n(n\in \omega)}(x)<f_{\beta+1}(x)<m_{\alpha+\omega}(x)<f_{\beta+1}(2^x)</math>

因而 MGH 与 FGH 在 <math>\omega^\omega</math> 处 Catching。

HH 为“下标 +1 则自变量 +1 ”，显然有<math>H_\alpha(H_\beta(n))=H_{\alpha+\beta}(n)</math>。

于是当 <math>H_{\alpha}(n)=f_{\beta}(n)</math> 时，

<math>H_{\alpha+1}(n)=f_\beta(n+1)</math>，<math>H_{\alpha+\alpha}(n)=f_\beta(f_\beta(n))</math>，<math>H_{\alpha\times\omega}(n)=f_{\beta+1}(n)</math>

而 <math>H_{1}(n)=f_{0}(n)=n+1</math>。于是我们又有以下推论：

相同基本列下，对于 <math>\beta\leq\alpha<\varepsilon_0</math>，有 <math>H_{\omega^{\alpha}}(n)=f_{\alpha}(n)</math>，<math>H_{\omega^\alpha+\omega^\beta}(n)=f_{\alpha}(f_{\beta}(n))</math>

因而 HH 与 FGH 在 <math>\varepsilon_0</math> 处 Catching。

我们最后再来看 SGH，其下标 +1 仅仅是“函数值 +1”，因而 SGH 的增长十分依赖于'''序数自身的结构'''及'''基本列'''的选取，所以其增长地较为缓慢，且在较小尺度上和 FGH 没有明显的对应关系。

SGH 与 FGH在<math>\psi(\Omega_\omega)</math>处 Catching。在这之后，直接分析记号的序数结构与分析增长率变得几乎没有区别。

=== 对照表 ===
以下是较为具体的对照表，黑色代表严格相等，绿色代表略小，红色代表略大。

<nowiki>\( \begin{array} { c | c | c } \rm FGH & \rm MGH & \rm HH & \rm SGH & \rm EXP & -\\ \hline & & H_0 & g_\omega & x\\ f_0 & m_0 & H_1 & g_{\omega +1} & x+1\\ f_0(f_0) & m_1 & H_2 & g_{\omega +2} & x+2\\ f_0^4 & m_2 & H_4 & g_{\omega +4} & x+4\\ f_0^8 & m_3 & H_8 & g_{\omega +8} & x+8\\ f_1 & \matrix{\underset{x+2^x}{\color{red}{ m_\omega}}} & H_\omega & g_{\omega \times 2} & 2x \\ f_1(f_0) & {\color{red}{ m_\omega}} & H_{\omega +1} & g_{\omega \times 2 +2} & 2x +2\\ f_1(f_0(f_0)) & {\color{red} {m_\omega}} & H_{\omega +2} & g_{\omega \times 2 +4} & 2x +4\\ f_1(f_1) & {\color{red} {m_\omega}} & H_{\omega \times 2} & g_{\omega \times 4} & 4x\\ f_1(f_1(f_0)) & {\color{red} {m_\omega}} & H_{\omega \times 2 +1} & g_{\omega \times 4 +4} & 4x +4\\ f_1(f_1(f_1)) & {\color{red} {m_\omega}} & H_{\omega \times 3} & g_{\omega \times 8} & 8x\\ f_2 & {\color{green} {m_\omega}} & H_{\omega ^2} & {\color{green}{ g_{\omega^2}\sim g_{\omega^n}}} & x\cdot 2^x\\ f_2(f_1) & {\color{green}{ m_\omega}} & H_{\omega ^2 +\omega} & {\color{green} {g_{\omega^2}\sim g_{\omega^n}}} & x\cdot 2^{2x+1}\\ f_2(f_2) & {\color{green} {m_{\omega +1}}} & H_{\omega ^2 \times 2} & {\color{green} {g_{\omega^\omega}\sim g_{\omega^{\omega^n}}}} & x\cdot 2^{x\cdot (2^x+1)}\\ f_3 & \matrix{\underset{>x\uparrow\uparrow 2^x}{\color{red} {m_{\omega \times 2}}}} & H_{\omega ^3} & \matrix{\underset{x\uparrow\uparrow x}{\color{green} {g_{\varepsilon_0}} }} & >x\uparrow\uparrow x \\ f_3(f_1) & {\color{red} {m_{\omega \times 2}}} & H_{\omega ^3 +\omega} & \matrix{\underset{>x\uparrow\uparrow 2x-1}{\color{green}{ g_{\varepsilon_1} }}} & >x\uparrow\uparrow 2x \\ f_3(f_2) & {\color{green} {m_{\omega \times 2}}} & H_{\omega ^3 +\omega ^2} & {\color{green} {g_{\varepsilon_\omega} \sim g_{\varepsilon_{\omega^n} }}} & >x\uparrow\uparrow (x\cdot 2^x) \\ f_3(f_3) & \matrix{\underset{>x\uparrow\uparrow x\uparrow\uparrow 2^x}{\color{red} {m_{\omega \times 2 +1}}}} & H_{\omega ^3 \times 2} & {\color{green} {g_{\varepsilon_{\varepsilon_0}} }} & >x\uparrow\uparrow x\uparrow\uparrow x &{\rm tritri}=3\uparrow\uparrow\uparrow3\\ f_3(f_3(f_2)) & {\color{green} {m_{\omega \times 2 +1}}} & H_{\omega ^3 \times 2 +\omega^2} & {\color{green} {g_{\varepsilon_{\varepsilon_\omega }}\sim g_{\varepsilon_{\varepsilon_{\omega^n} }} }} & >x\uparrow\uparrow x\uparrow\uparrow (x\cdot 2^x) \\ f_3(f_3(f_3)) & \matrix{\underset{>x\uparrow\uparrow\uparrow 5}{\color{red} {m_{\omega \times 2 +2}}}} & H_{\omega ^3 \times 3} & {\color{green}{ g_{\varepsilon_{\varepsilon_{\varepsilon_0}}}} } & >x\uparrow\uparrow\uparrow 4 \\ f_4 & \matrix{\underset{>x\uparrow\uparrow\uparrow 2^x}{\color{red} {m_{\omega \times 3}}}} & H_{\omega ^4} & {\color{green} {g_{\zeta_0}} } & >x\uparrow\uparrow\uparrow (x+1)\\ f_4(f_0) & {\color{red} {m_{\omega \times 3}}} & H_{\omega ^4+1} & {\color{green} {g_{\varepsilon_{\zeta_0+1}} }} & >x\uparrow\uparrow\uparrow (x+2) \\ f_4(f_1) & {\color{red} {m_{\omega \times 3}}} & H_{\omega ^4+\omega } & {\color{green}{ g_{\zeta_1}} } & >x\uparrow\uparrow\uparrow 2x \\ f_4(f_2) & {\color{green} {m_{\omega \times 3}}} & H_{\omega ^4+\omega^2 } & {\color{green} {g_{\zeta_\omega }\sim g_{\zeta_{\omega^n} } }} & >x\uparrow\uparrow\uparrow (x\cdot 2^x) \\ f_4(f_3) & {\color{green}{ m_{\omega \times 3}}} & H_{\omega ^4+\omega^3 } & {\color{green} {g_{\zeta_{\varepsilon _0}} } } & >x\uparrow\uparrow\uparrow x\uparrow\uparrow x \\ f_4(f_4) & {\color{red} {m_{\omega \times 3+1}}} & H_{\omega ^4\times 2 } & {\color{green}{ g_{\zeta_{\zeta _0} } }} & >x\uparrow\uparrow\uparrow x\uparrow\uparrow\uparrow x \\ f_5 & {\color{red} {m_{\omega \times 4}}} & H_{\omega ^5 } & {\color{green} {g_{\eta _0} } } & >x\uparrow\uparrow\uparrow\uparrow x & G(1)=3\uparrow^4 3\\ f_5(f_4) & {\color{green} {m_{\omega \times 4}}} & H_{\omega ^5 } & {\color{green} {g_{\eta_{\zeta _0}} } } & >x\uparrow^4 x\uparrow^3 x\\ f_5(f_5) & {\color{red}{ m_{\omega \times 4+1}}} & H_{\omega ^5\times 2 } & {\color{green} {g_{\eta_{\eta _0}}} } & >x\uparrow^4 x\uparrow^4 x\\ f_6 & {\color{red}{ m_{\omega \times 5}}} & H_{\omega ^6 } & {\color{green} {g_{\varphi(4,0) }} } & >x\uparrow^5 x\\ f_7 & {\color{red} {m_{\omega \times 6}}} & H_{\omega ^7 } & {\color{green} {g_{\varphi(5,0) }} } & >x\uparrow^6 x\\ \matrix{\underset{n>2,n\in \mathbb{N} }{f_n}} & {\color{red} {m_{\omega \times (n-1)}}} & H_{\omega ^n } & {\color{green}{ g_{\varphi(n-2,0) }} } & >x\uparrow^{n-1} x\\ f_\omega & \matrix{\underset{>x\uparrow^x x}{\color{red}{ m_{\omega^2}}}} & H_{\omega ^\omega } & \matrix{\underset{>x\uparrow^x x}{\color{red} {g_{\varphi(\omega ,0) }}} } & >x\uparrow^{x-1} x\\ \end{array} \)</nowiki>

得益于基本列，SGH 终于红了一次。但他的 <math>\varphi</math> 要开始猛进了。

\( \begin{array} { c | c | c } \rm FGH1 &\rm FGH2 & \rm MGH & \rm HH & \rm SGH & \rm EXP & -\\ \hline f_x &f_\omega & {\color{red}{ m_{\omega^2}}} & H_{\omega ^\omega } & {\color{red} {g_{\varphi(\omega ,0) }} } & >x\uparrow^{x-1} x\\ f_x(f_x)&f_x(f_\omega) & {\color{red}{ m_{\omega^2}}} & H_{\omega ^\omega } & {\color{red} {g_{\varphi(\omega ,0) }} } & >x\uparrow^{x-1} x\uparrow^{x-1} x\\ f_{x+1}(x+1)&f_\omega(f_0) & {\color{red}{ m_{\omega^2}}} & H_{\omega ^\omega +1 } & {\color{red} {g_{\varphi(\omega ,0) }} } & >x\uparrow^{x} x\\ f_{x+2}(x+2)&f_\omega(f_0(f_0)) & {\color{green}{ m_{\omega^2}}} & H_{\omega ^\omega +2 } & {\color{green} {g_{\varphi(\omega ,0) }} } & >x\uparrow^{x+1} x\\ f_{x+2}(f_{x+2})& & {\color{green}{ m_{\omega^2}}} & {\color{green}{H_{\omega ^\omega +2 }}} & {\color{green} {g_{\varphi(\omega ,\varphi(\omega ,0)) }} } & >x\uparrow^{x+1} x\uparrow^{x+1} x\\ f_{x+3}(x+3)&f_\omega(f_0^3) & {\color{green}{ m_{\omega^2}}} & H_{\omega ^\omega +3 } & {\color{green} {g_{\varphi(\omega+1 ,0) }} } & >x\uparrow^{x+2} x\\ f_{2x}(2x) &f_\omega(f_1) & \matrix{\underset{>x\uparrow^{x\uparrow^{x} x} x}{\color{red}{ m_{\omega^2+1}}}} & H_{\omega ^\omega +\omega } & {\color{red} {g_{\varphi(\omega \times 2 ,0) }} } & >x\uparrow^{2x-1} x\\ f_{2x+2}(2x+2)&f_\omega(f_1(f_0)) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega +1 } & {\color{green} {g_{\varphi(\omega \times 2 ,0) }} } & >x\uparrow^{2x +1} x\\ f_{2x+4}(2x+4)&f_\omega(f_1(f_0(f_0))) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega +2 } & {\color{green} {g_{\varphi(\omega \times 2 +2,0) }} } & >x\uparrow^{2x +3} x\\ f_{4x}(4x)&f_\omega(f_1(f_1)) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega\times 2 } & {\color{red} {g_{\varphi(\omega \times 4 ,0) }} } & >x\uparrow^{4x -1} x\\ f_{f_2}(f_2)&f_\omega(f_2) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega^2 } & {\color{green} {g_{\varphi(\omega ^2 ,0) }\sim g_{\varphi(\omega ^n ,0) }} } & >x\uparrow^{2^x} x\\ f_{f_3}(f_3)&f_\omega(f_3) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega^3 } & {\color{green} {g_{\varphi(\varepsilon _0 ,0) }} } & >x\uparrow^{x\uparrow\uparrow x} x\\ f_{f_4}(f_4)&f_\omega(f_4) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega +\omega^4 } & {\color{green} {g_{\varphi(\zeta _0 ,0) }} } & >x\uparrow^{x\uparrow\uparrow\uparrow x} x\\ f_{f_x}(f_x)&f_\omega(f_\omega ) & {\color{red}{ m_{\omega^2+1}}} & H_{\omega ^\omega \times 2 } & {\color{red} {g_{\varphi(\varphi(\omega ,0) ,0) }} } & >x\uparrow^{x\uparrow^{x-1} x} x & G(2)\\ f_<nowiki>{{f_{f_x}(f_x)}}</nowiki>(f_{f_x}(f_x)) &f_\omega(f_\omega(f_\omega ) ) & {\color{green}{ m_{\omega^2+1}}} & H_{\omega ^\omega \times 3 } & {\color{red} {g_{\varphi(\varphi(\varphi(\omega ,0) ,0) ,0) }} } & >x\uparrow^{x\uparrow^{x\uparrow^{x-1} x} x} x& G(3)\\ &f_{\omega+1} & {\color{red}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} } & {\color{green} {g_{\varphi(1,0,0) }} } & >x\to x\to x\to 2 & \color{red}{G(x)}\\ \end{array} \)

对于 <math>f_{\omega +1}</math> 后的增长率，建议直接使用 FGH 分析。

<nowiki>\( \begin{array} { c | c | c } \rm FGH1 &\rm FGH2 & \rm MGH & \rm HH & \rm SGH & -\\ \hline &f_{\omega+1} & {\color{red}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} } & {\color{green} {g_{\varphi(1,0,0) }=g_{\psi (\Omega ^\Omega ) }} } & \color{red}{G(x)}\\ f_{x+2}(f_{\omega+1})& & {\color{red}{ m_{\omega^2+\omega }}} & {\color{green} {H_{\omega ^{\omega+1}}} } & {\color{green} {g_{\varphi(\omega ,\varphi(1,0,0)+1) }} } & \color{red}{G(x)}\\ f_{f_{x+2}}(f_{\omega+1})& & {\color{red}{ m_{\omega^2+\omega }}} & {\color{green} {H_{\omega ^{\omega+1}}} } & {\color{green} {g_{\varphi(\varphi(\omega ,0) ,\varphi(1,0,0)+1) }} } & \color{red}{G(x)}\\ f_{\omega }(f_{\omega+1})=f_{\omega }^{x+1}(x+1)&f_{\omega+1}(f_0) & {\color{red}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} +1} & {\color{green} {g_{\varphi(\varphi(1,0,0),1) }} }& \color{green}{G(x)}\\ f_{\omega }^{x+2}(x+2)&f_{\omega+1}(f_0(f_0)) & {\color{red}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} +2} & {\color{green} {g_{\varphi(\varphi(\varphi(1,0,0),1),1) }} }& \color{green}{G(x+1)}\\ f_{\omega }^{2x}(2x)&f_{\omega+1}(f_1) & {\color{red}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} +\omega} & {\color{green} {g_{\varphi(1,0,1) }=g_{\psi (\Omega ^\Omega \times 2) }} }& \color{green}{G(2x-1)}\\ f_{\omega }^{x\cdot 2^x}(x\cdot 2^x)&f_{\omega+1}(f_2) & {\color{green}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} +\omega^2} & {\color{green} {g_{\varphi(1,0,\omega^2 )\sim \varphi(1,0,\omega^n )}} }& \\ f_{\omega }^{f_{\omega }}(f_{\omega })&f_{\omega+1}(f_\omega ) & {\color{green}{ m_{\omega^2+\omega }}} & H_{\omega ^{\omega+1} +\omega^\omega} & {\color{green} {g_{\varphi(1,0,\varphi(\omega ,0)) }} }& \\ f_{\omega }^{f_{\omega+1 }}(f_{\omega +1})&f_{\omega+1}(f_{\omega +1}) & {\color{red}{ m_{\omega^2+\omega +1 }}} & H_{\omega ^{\omega+1} \times 2} & {\color{green} {g_{\varphi(1,0,\varphi(1,0 ,0)) }} }& \color{green}{G(G(x-1))}\\ &f_{\omega+1}^3 & {\color{green}{ m_{\omega^2+\omega +1 }}} & H_{\omega ^{\omega+1} \times 3} & {\color{green} {g_{\varphi(1,0,\varphi(1,0 ,\varphi(1,0 ,0))) }} }& \color{green}{G(G(G(x-1)))}\\ &f_{\omega+2} & {\color{red}{ m_{\omega^2+\omega \times 2 }}} & H_{\omega ^{\omega+2} } & {\color{green} {g_{\varphi(1,1,0) }=g_{\psi (\Omega ^{\Omega+1} ) }} }&\\ f_{\omega}(f_{\omega+2})& & {\color{red}{ m_{\omega^2+\omega \times 2 }}} & {\color{green}{H_{\omega ^{\omega+2} }}} & {\color{green} {g_{\varphi(\varphi(1,1,0),1) }} }&\\ f_{\omega +1}(f_{\omega+2})=f_{\omega+1 }^{x+1}(x+1)&f_{\omega+2}(f_0) & {\color{red}{ m_{\omega^2+\omega \times 2 }}} & {H_{\omega ^{\omega+2}+1 }} & {\color{green} {g_{\varphi(1,0,\varphi(1,1,0)+1) }} }&\\ f_{\omega+1}^{2x}(2x)&f_{\omega+2}(f_1) & {\color{red}{ m_{\omega^2+\omega \times 2 }}} & H_{\omega ^{\omega+2}+\omega } & {\color{green} {g_{\varphi(1,1,1) }} }&\\ f_{\omega }^{f_{\omega+2 }}(f_{\omega +2})&f_{\omega+2}(f_{\omega +2}) & {\color{red}{ m_{\omega^2+\omega\times 2 +1 }}} & H_{\omega ^{\omega+2} \times 2} & {\color{green} {g_{\varphi(1,1,\varphi(1,1 ,0)) }} }& \\ &f_{\omega+3} & {\color{red}{ m_{\omega^2+\omega \times 3 }}} & H_{\omega ^{\omega+3} } & {\color{green} {g_{\varphi(1,2,0) }=g_{\psi (\Omega ^{\Omega+2} ) } }}&\\ &f_{\omega+4} & {\color{red}{ m_{\omega^2+\omega \times 4 }}} & H_{\omega ^{\omega+4} } & {\color{green} {g_{\varphi(1,3,0) }} }&\\ &f_{\omega\times 2} & {\color{red}{ m_{\omega^2\times 2 }}} & H_{\omega ^{\omega\times 2} } & {\color{red} {g_{\varphi(1,\omega ,0) }=g_{\psi (\Omega ^{\Omega+\omega })} } }&\\ \end{array} \)</nowiki>

<nowiki>\( \begin{array} { c | c | c } \rm FGH & \rm MGH & \rm HH & \rm SGH \\ \hline f_{\omega\times 2} & {\color{red}{ m_{\omega^2\times 2 }}} & H_{\omega ^{\omega\times 2} } & {\color{red} {g_{\varphi(1,\omega ,0) }}}\\ f_{\omega+2x+1}(f_{\omega\times 2}) & {\color{red}{ m_{\omega^2\times 2 }}} & {\color{green} {H_{\omega ^{\omega\times 2} }}} & {\color{green} {g_{\varphi(1,\omega\times 2 ,0) }}}\\ f_{\omega\times 2}(f_{\omega\times 2}) & {\color{red}{ m_{\omega^2\times 2 +1}}} & H_{\omega ^{\omega\times 2} \times 2} & {\color{red} {g_{\varphi(1,\varphi(1,\omega ,0) ,0) }}}\\ f_{\omega\times 2+1} & {\color{red}{ m_{\omega^2\times 2 +\omega }}} & H_{\omega ^{\omega\times 2 +1} } & {\color{green} {g_{\varphi(2,0 ,0)}=g_{\psi (\Omega ^{\Omega\times 2})}}}\\ f_{\omega\times 2+1}(f_1) & {\color{red}{ m_{\omega^2\times 2 +\omega }}} & H_{\omega ^{\omega\times 2 +1} +\omega } & {\color{green} {g_{\varphi(2,0 ,1) }}}\\ f_{\omega\times 2+1}(f_{\omega \times 2}) & {\color{red}{ m_{\omega^2\times 2 +\omega +1 }}} & H_{\omega ^{\omega\times 2 +1} +\omega^{\omega\times 2 } } & {\color{green} {g_{\varphi(2,0 ,\varphi(1,\omega ,0)) }}}\\ f_{\omega\times 2+1}(f_{\omega \times 2+1}) & {\color{red}{ m_{\omega^2\times 2 +\omega +1 }}} & H_{\omega ^{\omega\times 2 +1} \times 2} & {\color{green} {g_{\varphi(2,0 ,\varphi(2,0,0)) }}}\\ f_{\omega\times 2+2} & {\color{red}{ m_{\omega^2\times 2 +\omega\times 2 }}} & H_{\omega ^{\omega\times 2 +2} } & {\color{green} {g_{\varphi(2,1 ,0)}}}\\ f_{\omega\times 2+3} & {\color{red}{ m_{\omega^2\times 2 +\omega\times 3 }}} & H_{\omega ^{\omega\times 2+3} } & {\color{green} {g_{\varphi(2,2,0)}}}\\ f_{\omega\times 3} & {\color{red}{ m_{\omega^2\times 3 }}} & H_{\omega ^{\omega\times 3} } & {\color{red} {g_{\varphi(2,\omega,0)}}}\\ f_{\omega\times 3+1} & {\color{red}{ m_{\omega^2\times 3 +\omega }}} & H_{\omega ^{\omega\times 3+1}} & {\color{green} {g_{\varphi(3,0,0)}}}\\ f_{\omega\times 4} & {\color{red}{ m_{\omega^2\times 4 }}} & H_{\omega ^{\omega\times 4} } & {\color{red} {g_{\varphi(3,\omega,0)}}}\\ f_{\omega^2} & {\color{red}{ m_{\omega^3 }}} & H_{\omega ^{\omega^2} } & {\color{red} {g_{\varphi(\omega,0,0)}}}\\ f_{\omega^2}(f_{\omega^2}) & {\color{red}{ m_{\omega^3 \times 2}}} & H_{\omega ^{\omega^2}\times 2 } & {\color{red} {g_{\varphi(\varphi(\omega,0,0),0,0)}}}\\ f_{\omega^2+1} & {\color{red}{ m_{\omega^3 +\omega }}} & H_{\omega ^{\omega^2+1} } & {\color{green} {g_{\varphi(1,0,0,0)}=g_{\psi (\Omega ^{\Omega^2})}}}\\ f_{\omega^2+\omega} & {\color{red}{ m_{\omega^3 +\omega^2 }}} & H_{\omega ^{\omega^2+\omega }} & {\color{red} {g_{\varphi(1,0,\omega,0)}}}\\ f_{\omega^2+\omega +1} & {\color{red}{ m_{\omega^3 +\omega^2 +\omega }}} & H_{\omega ^{\omega^2+\omega+1 }} & {\color{green} {g_{\varphi(1,1,0,0)}}}\\ f_{\omega^2+\omega\times 2 +1} & {\color{red}{ m_{\omega^3 +\omega^2\times 2 +\omega }}} & H_{\omega ^{\omega^2+\omega\times 2+1 }} & {\color{green} {g_{\varphi(1,2,0,0)}}}\\ f_{\omega^2\times 2} & {\color{red}{ m_{\omega^3 \times 2 }}} & H_{\omega ^{\omega^2\times 2 }} & {\color{red} {g_{\varphi(1,\omega ,0,0)}}}\\ f_{\omega^2\times 2 +1} & {\color{red}{ m_{\omega^3 \times 2 +\omega }}} & H_{\omega ^{\omega^2\times 2 +1}} & {\color{green} {g_{\varphi(2,0,0,0)}}}\\ f_{\omega^2\times 3 +1} & {\color{red}{ m_{\omega^3 \times 3 +\omega }}} & H_{\omega ^{\omega^2\times 3 +1}} & {\color{green} {g_{\varphi(3,0,0,0)}}}\\ f_{\omega^3} & {\color{red}{ m_{\omega^4 }}} & H_{\omega ^{\omega^3}} & {\color{red} {g_{\varphi(\omega,0,0,0)}=g_{\psi (\Omega ^{\Omega^2\times \omega})}}}\\ f_{\omega^3+1} & {\color{red}{ m_{\omega^4+\omega }}} & H_{\omega ^{\omega^3+1}} & {\color{green} {g_{\varphi(1@4)}=g_{\psi (\Omega ^{\Omega^3})}}}\\ f_{\omega^4+1} & {\color{red}{ m_{\omega^5+\omega }}} & H_{\omega ^{\omega^4+1}} & {\color{green} {g_{\varphi(1@5)}=g_{\psi (\Omega ^{\Omega^4})}}}\\ f_{\omega^\omega} & {\color{green}{ m_{\omega^\omega }}} & H_{\omega ^{\omega^\omega }} & {\color{green} {g_{\varphi(1@\omega)}}}={\color{red} {g_{\psi (\Omega ^{\Omega^\omega})}}}\\ \end{array} \)</nowiki>

同样是由于基本列，MGH 与 FGH 在 <math>\omega^\omega</math> 处 Catching 但略小于 FGH（注意 Catching 并不是相等），此后每遇到 <math>\omega^\omega</math> 的倍数二者都会 Catching 一次。

<nowiki>\( \begin{array} { c | c | c } \rm FGH & \rm HH & \rm SGH \\ \hline f_{\omega^\omega} & H_{\omega ^{\omega^\omega }} & {\color{green} {g_{\varphi(1@\omega)}}}={\color{red} {g_{\psi (\Omega ^{\Omega^\omega})}}}\\ f_{\omega^\omega}(f_0) & H_{\omega ^{\omega^\omega }+1} & {\color{green} {g_{\varphi(1@(\omega+1))}}}\\ f_{\omega^\omega}(f_1) & H_{\omega ^{\omega^\omega }+\omega } & {\color{green} {g_{\varphi(1@(\omega\times 2))}}}\\ f_{\omega^\omega}(f_{\omega^\omega}) & H_{\omega ^{\omega^\omega }\times 2 } & {\color{green} {g_{\varphi(1@\varphi(1@\omega))}}}\\ f_{\omega^\omega+1} & H_{\omega ^{\omega^\omega +1}} & {\color{green} {g_{\varphi(1@(1,0))}= {g_{\psi (\Omega ^{\Omega^\Omega})}}}}\\ f_{\omega^\omega+\omega } & H_{\omega ^{\omega^\omega +\omega }} & {\color{red} {g_{\psi (\Omega ^{\Omega^\Omega+\omega })}}}\\ f_{\omega^\omega+\omega +1 } & H_{\omega ^{\omega^\omega +\omega +1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega })}}}\\ f_{\omega^\omega+\omega\times 2 +1 } & H_{\omega ^{\omega^\omega +\omega\times 2 +1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega\times 2 })}}}\\ f_{\omega^\omega+\omega^2 } & H_{\omega ^{\omega^\omega +\omega^ 2 }} & {\color{red} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega\times \omega })}}}\\ f_{\omega^\omega+\omega^2 +1 } & H_{\omega ^{\omega^\omega +\omega^ 2 +1 }} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega^2 })}}}\\ f_{\omega^\omega+\omega^3 +1 } & H_{\omega ^{\omega^\omega +\omega^ 3 +1 }} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega^3 })}}}\\ f_{\omega^\omega\times 2 } & H_{\omega ^{\omega^\omega \times 2 }} & {\color{red} {g_{\psi (\Omega ^{\Omega^\Omega+\Omega^\omega })}}}\\ f_{\omega^\omega\times 2 +1} & H_{\omega ^{\omega^\omega \times 2 +1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega\times 2 })}}}\\ f_{\omega^\omega\times 3 +1} & H_{\omega ^{\omega^\omega \times 3 +1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^\Omega\times 3})}}}\\ f_{\omega^{\omega+1}} & H_{\omega ^{\omega^{\omega +1}}} & {\color{red} {g_{\psi (\Omega ^{\Omega^\Omega\times \omega })}}}\\ f_{\omega^{\omega+1}+1} & H_{\omega ^{\omega^{\omega +1}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega+1} })}}}\\ f_{\omega^{\omega+1}+\omega +1} & H_{\omega ^{\omega^{\omega +1}+\omega +1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega+1}+\Omega })}}}\\ f_{\omega^{\omega+1}\times 2+1} & H_{\omega ^{\omega^{\omega +1} \times 2} } & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega+1}\times 2 })}}}\\ f_{\omega^{\omega+2}} & H_{\omega ^{\omega^{\omega +2}}} & {\color{red} {g_{\psi (\Omega ^{\Omega^{\Omega+1}\times \omega })}}}\\ f_{\omega^{\omega+2}+1} & H_{\omega ^{\omega^{\omega +2}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega+2} })}}}\\ f_{\omega^{\omega+3}+1} & H_{\omega ^{\omega^{\omega +3}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega+3} })}}}\\ f_{\omega^{\omega\times 2}} & H_{\omega ^{\omega^{\omega \times 2}}} & {\color{red} {g_{\psi (\Omega ^{\Omega^{\Omega+\omega } })}}}\\ f_{\omega^{\omega\times 2}+1} & H_{\omega ^{\omega^{\omega \times 2}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega\times 2 } })}}}\\ f_{\omega^{\omega\times 3}+1} & H_{\omega ^{\omega^{\omega \times 3}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega\times 3 } })}}}\\ f_{\omega^{\omega^ 2}} & H_{\omega ^{\omega^{\omega ^ 2}}} & {\color{red} {g_{\psi (\Omega ^{\Omega^{\Omega\times \omega } })}}}\\ f_{\omega^{\omega^ 2}+1} & H_{\omega ^{\omega^{\omega ^ 2}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega^2 } })}}}\\ f_{\omega^{\omega^ 3}+1} & H_{\omega ^{\omega^{\omega ^ 3}+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega^3 } })}}}\\ f_{\omega^{\omega^ \omega }} & H_{\omega ^{\omega^{\omega ^ \omega }}} & {\color{red} {g_{\psi (\Omega ^{\Omega^{\Omega^\omega } })}}}\\ f_{\omega^{\omega^ \omega }+1} & H_{\omega ^{\omega^{\omega ^ \omega }+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega^\Omega } })}}}\\ f_{\omega^{\omega^{\omega^ \omega } }+1} & H_{\omega ^{\omega^{\omega ^{\omega^ \omega } }+1}} & {\color{green} {g_{\psi (\Omega ^{\Omega^{\Omega^{\Omega^ \Omega } } })}}}\\ f_{\psi (0)=\varepsilon_0} & {\color{green}{H_{\varepsilon _0}}}/H_{\varepsilon _0+1} & {\color{green} {g_{\psi (\psi_1(0))}}}\\ \end{array} \)</nowiki>

HH 与 FGH 最终在 <math>\varepsilon_0</math> 处 Catching 了。此后每遇到 <math>\varepsilon_0</math> 的倍数二者都会再次 Catching。

关于这之后 SGH 与 FGH 的对照分析，请移步 [[Catching 函数]]。

=== 警告 ===
读者需要非常谨慎，因为个人网站、视频和用户博客上存在许多错误的“入门介绍”，尽管这些内容不幸受到初学者的青睐。由于序数、基本列等数学概念非常抽象且难以精确处理，人们往往倾向于给出直观描述——这些描述对初学者来说比精确解释更简单、更“酷”。然而，这类“入门介绍”经常包含严重错误，因为作者本身也是通过其他直观描述学习的，而非精确的定义——重点在于，要理解快速增长层级，精确的定义是不可或缺的。精确描述看起来复杂的原因并非仅仅是表述不佳或冗余，而是因为这些概念本身确实非常困难，尽管这些错误的“入门介绍”有时会将它们解释为简单的概念。

另外要注意，关于快速增长层级中函数的可计算性，存在许多错误描述。虽然 gggists 有时会声称某个函数是可计算的，因为它是通过快速增长层级定义的，但这是典型的错误。通过包含无限序数的方法(如快速增长层级)定义的函数并不一定是可计算的。为了确保通过快速增长层级定义的函数的可计算性，我们需要构造一个明确的算法来计算它，常见例子是由序数记号给出一个基本列的算法。即使快速增长层级中像 <math>f_\omega</math> 这样的较小函数，若没有通过明确算法定义，也可能是不可计算的(比如设想<math>f_\omega(n)=f_{BB(n)}(n)</math>，其中<math>BB(n)</math>是[[忙碌海狸函数]])。因为算法只能处理可数集合中具有固定枚举的元素，而无法直接处理没有固定枚举的集合中的无限序数。为了解决可计算性问题，我们通常使用序数记号。

关于快速增长层级（及其同类，如哈代层级和慢速增长层级）最重要的事实之一是：给定上界以下的极限序数的基本列系统并非唯一，经典增长层级严重依赖于这种系统的选择；除非在上下文中明确固定了基本列系统的具体选择，否则它是定义不明确的。初学者必须非常注意这个问题，因为当 gggist 谈论“Catching 的序数”“视为增长率的序数”“快速增长层级中的证明论序数”等内容时，若不理解基本列系统选择的依赖性，这种定义不明确的情况会频繁出现。

=== 参考文献 ===
<references />
[[分类:入门]]
[[分类:分析]]

0-Y

2025-07-18T00:56:00Z

Apocalypse：

'''0-Y'''是一种[[Beklemishev's Worm|Worm]]型序数记号，它是[[初等序列系统|PrSS]]的一种扩展。

== 定义 ==

=== 合法表达式 ===
一个合法的 0-Y 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 0-Y 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
0-Y的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。第<math>i</math>行第<math>j</math>列的项记为<math>x_{i,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 父项与阶差项 ====
等于1的项没有父项。对于大于1的项<math>x_{i,j}</math>，它的父项与它位于同一行，且是满足以下条件的最右侧项<math>x_{i,k}</math>：

* <math>k<j</math>且<math>x_{i,k}<x_{i,j}</math>。
* 如果<math>i>0</math>，还要求<math>x_{i-1,k}</math>是<math>x_{i-1,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于<math>x_{i,j}</math>，如果它有父项<math>x_{i,k}</math>，则它的阶差项为<math>x_{i+1,j}=x_{i,j}-x_{i,k}</math>；如果<math>x_{i,j}=1</math>，则它的阶差项<math>x_{i+1,j}=1</math>。

由于第<math>i</math>行的项的阶差项构成了第<math>i+1</math>行，称第<math>i+1</math>行的序列是第<math>i</math>行的序列的'''阶差序列'''。

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{i,n}</math>，它的父项设为<math>x_{i,r}</math>。如果在计算到某行(第<math>p</math>行)时有<math>x_{p,n}-x_{p,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''，并且不再计算第<math>p+1</math>行及之后的行。

以上给出了 0-Y 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述0-Y的展开规则，需要用到'''山脉图'''的辅助。对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则画出第0到<math>p</math>行。现在你有了一个<math>p\times{n}</math>的“矩阵”(第0至第<math>p</math>行，第1至第<math>n</math>列)，接下来，对于第<math>i</math>行，<math>0\leq{i}\leq{p-1}</math>进行如下操作：

对于每个<math>x_{i,j}</math>，用竖直线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,j}</math>的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math>称为它的端点。

对于每个大于1的<math>x_{i,j}</math>，设<math>x_{i,j}</math>有父项<math>x_{i,k}</math>，用斜线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,k}</math>的上端。这些斜线段称为'''左腿'''，<math>x_{i,k}</math>称为它的端点。

对第1到第<math>p</math>行各执行一次上述操作，就得到了<math>(a_1,a_2,\cdots,a_n)</math>的山脉图。

注意：有些情况下，山脉图只包含一行，即第0行。

注：由于山脉图的某一行只和其下的项有关，你也可以在逐行往上填写阶差序列的同时画出山脉图。许多常见的0-Y教程都采用这个方法。

''(待补充附有配图的0-Y山脉图绘制例子,以及绘制0-Y山脉图的网站(有吗))''

== 展开 ==
对于 0-Y 的一个表达式<math>(a_1,a_2,\cdots,a_n)</math>：

* 如果它是零表达式，它对应序数0。
* 如果它是后继表达式，它对应<math>(a_1,a_2,\cdots,a_{n-1})</math>的后继。
* 如果它是极限表达式，它的基本列第<math>q</math>项如下确定：

# 作出<math>p\times{n}</math>的山脉图。称位于根列右侧的结构(包括阶差项和其对应的山脉图中的左右腿，不包括根列)为'''坏部'''，其余为'''好部'''。
# 删除坏部中第<math>p</math>行以下的所有项，并将<math>x_{p,n}</math>减1。
# 接下来，保留山脉图的好部不动，将坏部平移并复制在山脉图末尾，复制<math>q-1</math>次。“坏部平移”是指左右腿及端点同时平移。
# 特别地，如果某一条左腿的端点位于根列左侧，复制时左腿的端点不向右平移。
# 接下来，你得到了根列右侧的一系列山脉图和第<math>p</math>行的一系列项。从根列右侧开始，从上到下，每一行从左到右，按照以下方式填入正整数：对于某个位置，向上通过右腿移动到值为<math>x</math>的项，然后向左下通过左腿移动到值为<math>y</math>的项，则回到初始位置并填上<math>x+y</math>。
# 最后得到的第0行的序列，就是<math>(a_1,a_2,\cdots,a_n)</math>展开的基本列第<math>q-1</math>项。

0-Y的极限基本列是<math>\{(1,2),(1,3),(1,4),\cdots\}</math>，从这个基本列中元素开始取前驱或取基本列所能得到的表达式是 0-Y 的标准式。

''(待补充附有配图的0-Y展开例子,比如Y(1,4,6,4)和Y(1,4,6,3,7,9,7),后者有不平移的端点)''

== 枚举 ==
我们使用 [[Bashicu矩阵|BMS]] 对 0-Y 进行简单分析(左边是BMS，右边是0-Y)。

<math>(0)=1</math>

<math>(0)(1)=1,2</math>

<math>(0)(1)(1)=1,2,2</math>

<math>(0)(1)(2)=1,2,3</math>

<math>(0)(1)(2)(3)=1,2,3,4</math>

<math>(0)(1,1)=1,3</math>

<math>(0)(1,1)(1,0)=1,3,2</math>

<math>(0)(1,1)(1,0)(2,1)=1,3,2,4</math>

<math>(0)(1,1)(1,1)=1,3,3</math>

<math>(0)(1,1)(2,0)=1,3,4</math>

<math>(0)(1,1)(2,0)(3,1)=1,3,4,6</math>

<math>(0)(1,1)(2,1)=1,3,5</math>

<math>(0)(1,1)(2,1)(3,1)=1,3,5,7</math>

<math>(0)(1,1)(2,2)=1,3,6</math>

<math>(0)(1,1)(2,2)(3,3)=1,3,6,10</math>

<math>(0)(1,1,1)=1,4</math>

<math>(0)(1,1,1)(1,0,0)(2,1,1)=1,4,2,5</math>

<math>(0)(1,1,1)(1,1,0)=1,4,3</math>

<math>(0)(1,1,1)(1,1,0)(2,2,1)=1,4,3,7</math>

<math>(0)(1,1,1)(1,1,1)=1,4,4</math>

<math>(0)(1,1,1)(2,0,0)=1,4,5</math>

<math>(0)(1,1,1)(2,1,0)=1,4,6</math>

<math>(0)(1,1,1)(2,1,0)(1,1,1)=1,4,6,4</math>

<math>(0)(1,1,1)(2,1,0)(3,1,0)=1,4,6,8</math>

<math>(0)(1,1,1)(2,1,0)(3,2,1)=1,4,6,10</math>

<math>(0)(1,1,1)(2,1,1)=1,4,7</math>

<math>(0)(1,1,1)(2,1,1)(3,1,1)=1,4,7,10</math>

<math>(0)(1,1,1)(2,2,0)=1,4,8</math>

<math>(0)(1,1,1)(2,2,1)=1,4,9</math>

<math>(0)(1,1,1)(2,2,2)=1,4,10</math>

<math>(0)(1,1,1)(2,2,2)(3,3,3)=1,4,10,20</math>

<math>(0)(1,1,1,1)=1,5</math>

<math>(0)(1,1,1,1,1)=1,6</math>

<math>\cdots</math>

两者极限相等。

== 与[[Bashicu矩阵|BMS]]的互译 ==
事实上，0-Y与[[Bashicu矩阵|BMS]]有十分简单的互译关系。

''(等待更新)''

[[分类:记号]]

0-Y

2025-07-18T00:07:27Z

Apocalypse：创建页面，内容为“'''0-Y'''是一种Worm型序数记号，它是PrSS的一种扩展。 == 定义 == === 合法表达式 === 一个合法的 0-Y 表达式是以 1 开头的正整数序列，即形如 <math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math> 的序列。例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 0-Y 表达式，而<math>(1,2,\pi)</math>不是。 === 结构 === 0-Y…”

'''0-Y'''是一种[[Beklemishev's Worm|Worm]]型序数记号，它是[[初等序列系统|PrSS]]的一种扩展。

== 定义 ==

=== 合法表达式 ===
一个合法的 0-Y 表达式是以 1 开头的正整数序列，即形如

<math>(a_1,a_2,\cdots,a_n)\quad(n,a_1,a_2,\cdots,a_n\in\N,a_1=1)</math>

的序列。

例如：<math>(1,4,6,4)</math>和<math>(1,1,4,5,1,4)</math>都是合法的 0-Y 表达式，而<math>(1,2,\pi)</math>不是。

=== 结构 ===
0-Y的合法表达式可分为'''零表达式'''、'''后继表达式'''和'''极限表达式'''。

* '''零表达式'''指<math>n=0</math>的表达式，即空序列；
* '''后继表达式'''指<math>n>0,a_n=1</math>的表达式，即末项为1的非空序列；
* '''极限表达式'''指<math>n>0,a_n>1</math>的表达式，末项不为1的非空序列。

对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，定义以下术语：

==== 行标与列标 ====
设想我们在一个无限大的矩阵下工作，从左往右是第1,2,...列，从下往上是第0,1,...行。第<math>i</math>行第<math>j</math>列的项记为<math>x_{i,j}</math>。

初始时，我们有<math>x_{0,j}=a_j</math>，<math>1\leq{j}\leq{n}</math>。

==== 父项与阶差项 ====
等于1的项没有父项。对于大于1的项<math>x_{i,j}</math>，它的父项与它位于同一行，且是满足以下条件的最右侧项<math>x_{i,k}</math>：

* <math>k<j</math>且<math>x_{i,k}<x_{i,j}</math>。
* 如果<math>i>0</math>，还要求<math>x_{i-1,k}</math>是<math>x_{i-1,j}</math>的祖先项。

这里“祖先项”的定义类似于[[Bashicu矩阵|BMS]]：一个元素自己，以及它的父项、父项的父项、父项的父项的父项......共同构成它的祖先项。

对于<math>x_{i,j}</math>，如果它有父项<math>x_{i,k}</math>，则它的阶差项为<math>x_{i+1,j}=x_{i,j}-x_{i,k}</math>；如果<math>x_{i,j}=1</math>，则它的阶差项<math>x_{i+1,j}=1</math>。

由于第<math>i</math>行的项的阶差项构成了第<math>i+1</math>行，称第<math>i+1</math>行的序列是第<math>i</math>行的序列的'''阶差序列'''。

==== 末列与坏根 ====
第<math>n</math>列称为'''末列'''。

对于末列的某一项<math>x_{i,n}</math>，它的父项设为<math>x_{i,r}</math>。如果在计算到某行(第<math>p</math>行)时有<math>x_{p,n}-x_{p,r}=1</math>，则称<math>a_r</math>为'''坏根'''，称第<math>r</math>列为'''根列'''，并且不再计算第<math>p+1</math>行及之后的行。

以上给出了 0-Y 极限表达式<math>(a_1,a_2,\cdots,a_n)</math>的完整寻找坏根流程。

== 山脉图 ==
要描述0-Y的展开规则，需要用到'''山脉图'''的辅助。对于 0-Y 的一个极限表达式<math>(a_1,a_2,\cdots,a_n)</math>，它的山脉图的画法如下：

先按照寻找坏根的规则画出第0到<math>p</math>行。现在你有了一个<math>p\times{n}</math>的“矩阵”(第0至第<math>p</math>行，第1至第<math>n</math>列)，接下来，对于第<math>i+1</math>行，<math>0\leq{i}\leq{p-1}</math>进行如下操作：

对于每个<math>x_{i,j}</math>，用竖直线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,j}</math>的上端。这些竖直线段称为'''右腿'''，<math>x_{i,j}</math>称为它的端点。

对于每个大于1的<math>x_{i,j}</math>，设<math>x_{i,j}</math>有父项<math>x_{i,k}</math>，用斜线段连接<math>x_{i+1,j}</math>的下端与<math>x_{i,k}</math>的上端。这些斜线段称为'''左腿'''，<math>x_{i,k}</math>称为它的端点。

对第1到第<math>p</math>行各执行一次上述操作，就得到了<math>(a_1,a_2,\cdots,a_n)</math>的山脉图。

注意：有些情况下，山脉图只包含一行，即第0行。

''(待补充附有配图的0-Y山脉图绘制例子,以及绘制0-Y山脉图的网站(有吗))''

== 展开 ==
对于 0-Y 的一个表达式<math>(a_1,a_2,\cdots,a_n)</math>：

* 如果它是零表达式，它对应序数0。
* 如果它是后继表达式，它对应<math>(a_1,a_2,\cdots,a_{n-1})</math>的后继。
* 如果它是极限表达式，它的基本列第<math>q</math>项如下确定：

# 作出<math>p\times{n}</math>的山脉图。称位于根列右侧的结构(包括阶差项和其对应的左右腿，不包括根列)为'''坏部'''，其余为'''好部'''。
# 删除坏部中第<math>p</math>行以下的所有项，并将<math>x_{p,n}</math>减1。
# 接下来，保留山脉图的好部不动，将坏部平移并复制在山脉图末尾，复制<math>q-1</math>次。“坏部平移”是指左右腿及端点同时平移。
# 特别地，如果某一条左腿的端点位于根列左侧，复制时左腿的端点不向右平移。
# 接下来，你得到了根列右侧的一系列山脉图和第<math>p</math>行的一系列项。从根列右侧开始，从上到下，每一行从左到右，按照以下方式填入正整数：对于某个位置，向上通过右腿移动到值为<math>x</math>的项，然后向左下通过左腿移动到值为<math>y</math>的项，则回到初始位置并填上<math>x+y</math>。
# 最后得到的第0行的序列，就是<math>(a_1,a_2,\cdots,a_n)</math>展开的基本列第<math>q-1</math>项。

0-Y的极限基本列是<math>\{(1,2),(1,3),(1,4),\cdots\}</math>，从这个基本列中元素开始取前驱或取基本列所能得到的表达式是 0-Y 的标准式。

''(待补充附有配图的0-Y展开例子,比如Y(1,4,6,4)和Y(1,4,6,3,7,9,7),后者有不平移的端点)''

== 枚举 ==
我们使用 [[Bashicu矩阵|BMS]] 对 0-Y 进行简单分析(左边是BMS，右边是0-Y)。

<math>(0)=1</math>

<math>(0)(1)=1,2</math>

<math>(0)(1)(1)=1,2,2</math>

<math>(0)(1)(2)=1,2,3</math>

<math>(0)(1)(2)(3)=1,2,3,4</math>

<math>(0)(1,1)=1,3</math>

<math>(0)(1,1)(1,0)=1,3,2</math>

<math>(0)(1,1)(1,0)(2,1)=1,3,2,4</math>

<math>(0)(1,1)(1,1)=1,3,3</math>

<math>(0)(1,1)(2,0)=1,3,4</math>

<math>(0)(1,1)(2,0)(3,1)=1,3,4,6</math>

<math>(0)(1,1)(2,1)=1,3,5</math>

<math>(0)(1,1)(2,1)(3,1)=1,3,5,7</math>

<math>(0)(1,1)(2,2)=1,3,6</math>

<math>(0)(1,1)(2,2)(3,3)=1,3,6,10</math>

<math>(0)(1,1,1)=1,4</math>

<math>(0)(1,1,1)(1,0,0)(2,1,1)=1,4,2,5</math>

<math>(0)(1,1,1)(1,1,0)=1,4,3</math>

<math>(0)(1,1,1)(1,1,0)(2,2,1)=1,4,3,7</math>

<math>(0)(1,1,1)(1,1,1)=1,4,4</math>

<math>(0)(1,1,1)(2,0,0)=1,4,5</math>

<math>(0)(1,1,1)(2,1,0)=1,4,6</math>

<math>(0)(1,1,1)(2,1,0)(1,1,1)=1,4,6,4</math>

<math>(0)(1,1,1)(2,1,0)(3,1,0)=1,4,6,8</math>

<math>(0)(1,1,1)(2,1,0)(3,2,1)=1,4,6,10</math>

<math>(0)(1,1,1)(2,1,1)=1,4,7</math>

<math>(0)(1,1,1)(2,1,1)(3,1,1)=1,4,7,10</math>

<math>(0)(1,1,1)(2,2,0)=1,4,8</math>

<math>(0)(1,1,1)(2,2,1)=1,4,9</math>

<math>(0)(1,1,1)(2,2,2)=1,4,10</math>

<math>(0)(1,1,1)(2,2,2)(3,3,3)=1,4,10,20</math>

<math>(0)(1,1,1,1)=1,5</math>

<math>(0)(1,1,1,1,1)=1,6</math>

<math>\cdots</math>

两者极限相等。

== 与[[Bashicu矩阵|BMS]]的互译 ==
事实上，0-Y与[[Bashicu矩阵|BMS]]有十分简单的互译关系。

''(等待更新)''

[[分类:记号]]

SCG函数 & SSCG函数

2025-07-17T21:39:10Z

Apocalypse：创建页面，内容为“'''SCG(SubCubic Graph number)函数'''和'''SSCG(Simple SubCubic Graph number)函数'''是两个由Harvey Friedman提出的图论函数。 == 定义 == === 图的嵌入 === 给定两个图<math>A</math>和<math>B</math>，我们称<math>A</math>能嵌入到<math>B</math>中，如果<math>B</math>能通过有限次以下操作得到<math>A</math>： * 删除一个度为0的点，即没有连接边的点。 * 删除一条边。 * 对于一条连接两个不同…”

'''SCG(SubCubic Graph number)函数'''和'''SSCG(Simple SubCubic Graph number)函数'''是两个由Harvey Friedman提出的图论函数。

== 定义 ==

=== 图的嵌入 ===
给定两个图<math>A</math>和<math>B</math>，我们称<math>A</math>能嵌入到<math>B</math>中，如果<math>B</math>能通过有限次以下操作得到<math>A</math>：

* 删除一个度为0的点，即没有连接边的点。
* 删除一条边。
* 对于一条连接两个不同顶点的边<math>e=(u,v)</math>，删除该边，并且合并两个顶点为一个新顶点<math>x</math>(也即将所有的边<math>(p,q)</math>中出现的<math>u</math>和<math>v</math>都替换为<math>x</math>)。

=== SCG(n) ===
给定正整数n，<math>\rm SCG(n)</math>被定义为满足以下条件的“图列”<math>\{G_k\}</math>的最大长度：

# 所有图的每个顶点度数<math>\leq3</math>；
# <math>G_k</math>至多有<math>n+k</math>个顶点；
# 对于正整数<math>k<l</math>，<math>G_k</math>不能嵌入到<math>G_l</math>中。

=== SSCG(n) ===
<math>\rm SSCG(n)</math>是<math>\rm SCG(n)</math>在简单图上的限制。

给定正整数n，<math>\rm SCG(n)</math>被定义为满足以下条件的“图列”<math>\{G_k\}</math>的最大长度：

# 所有图的每个顶点度数<math>\leq3</math> 且无自环和重边；
# <math>G_k</math>至多有<math>n+k</math>个顶点；
# 对于正整数<math>k<l</math>，<math>G_k</math>不能嵌入到<math>G_l</math>中。

== 有限性证明 ==
<math>\rm SCG(n)</math>和<math>\rm SSCG(n)</math>的序列总是有限的，这可由Robertson-Seymour定理保证。

Robertson-Seymour定理说明，有限图的嵌入关系是一个良拟序，良拟序的定义参考[[TREE函数#有限性证明|这里]]。

也就是说，任意无限张图构成的序列中，必存在两张图，前面的图能嵌入到后面的图中。这就证明了<math>\rm SCG(n)</math>和<math>\rm SSCG(n)</math>的有限性。

== 取值 ==
对于较小的n，我们有

<math>\rm SCG(0)=6</math>

<math>\rm SSCG(0)=2</math>

<math>\rm SSCG(1)=5</math>

<math>{\rm SSCG(2)}\geq{3\times2^{3\times2^{95}}}-8</math>

以及一些下界<ref>https://googology.fandom.com/wiki/User_blog:Hyp_cos/SCG(n)_and_some_related</ref><ref>https://www.zhihu.com/question/665933771/answer/3619954642</ref>

<math>{\rm SCG(1)}>f_{\varepsilon_2\times2}(f_{\varepsilon_0\times2}(f_{\varepsilon_0+1}(f_\varepsilon_0(f_{\omega^\omega+1}(f_{\omega^5+\omega^2+\omega}(f_{\omega^2\times3+1}(f_{\omega^2\times2+1}(f_{\omega^2+\omega\times3+1}(f_{\omega^2+1}(f_{\omega^2}({3\times2^{3\times2^{95}}})))))))))))</math>

<math>{\rm SCG(2)}>f_{\psi(\Omega^{\Omega^\omega})}(f_{\varepsilon_2\times2}(f_{\varepsilon_0\times2}(f_{\varepsilon_0+1}(f_\varepsilon_0(f_{\omega^\omega+1}(f_{\omega^5+\omega^2+\omega}(f_{\omega^2\times3+1}(f_{\omega^2\times2+1}(f_{\omega^2+\omega\times3+1}(f_{\omega^2+1}(f_{\omega^2}({3\times2^{3\times2^{95}}}))))))))))))</math>

<math>{\rm SSCG(3)}>{\rm TREE^{\rm TREE(3)}(3)}</math>

<math>\rm SCG(2)</math>的下界小于<math>\rm TREE(3)</math>，目前无法判断它们之间的大小关系。

== 增长率 ==
我们可以证明<math>{\rm SSCG(n)}\geq{\rm SCG(n)}\geq{\rm SSCG(4n+3)}</math>。因此<math>\rm SCG(n)</math>和<math>\rm SSCG(n)</math>有相同的增长率。

类似于[[TREE函数#增长率|TREE函数的增长率]]，只要对所有图的嵌入关系进行编序，即可得出它们的增长率。

然而这仍然是一个未解决的问题，目前我们只对所有平面图进行了编序，并且这一步就用掉了所有<math>\psi(\Omega_\omega)</math>之下的序数。因此，这两个函数的增长率下界为<math>\psi(\Omega_\omega)</math>。

我们认为增长率的上界可能为<math>\psi(\Omega_{\omega+1})</math>。

我们尚不知道这两个函数增长率的具体取值。
== 参考资料 ==
<references />
[[分类:记号]]

TREE函数

2025-07-17T20:02:49Z

Apocalypse：

'''TREE函数'''是由数理逻辑学家Harvey Friedman提出的图论函数。

== 定义 ==

=== 树的嵌入 ===
[[文件:树的嵌入.png|缩略图]]
给定两棵树<math>A</math>和<math>B</math>，我们称<math>A</math>能嵌入到<math>B</math>中，如果<math>B</math>能通过有限次以下操作得到<math>A</math>：

* 删除一个叶子节点。
* 若某点只有两条边和它连接，删除这个点，用一条边连接与它相邻的两个顶点(即将两条相邻的边合并成一条)。
例如，图中右边的两棵树均能嵌入到左边的树中，但它们不能互相嵌入。

=== TREE(n) ===
TREE函数研究的是一类特殊的树，其每个顶点被赋予一个值，称为该点的“颜色”。

给定正整数n，<math>\rm TREE(n)</math>被定义为满足以下条件的“树列”<math>\{T_n\}</math>的最大长度：

# 所有树的顶点至多有<math>n</math>种不同的颜色；
# <math>T_k</math>至多有<math>k</math>个顶点；
# 对于正整数<math>k<l</math>，<math>T_k</math>不能嵌入到<math>T_l</math>中。

=== tree(n) ===
<math>\rm tree(n)</math>(注意大小写)被称为'''弱tree函数'''，它研究的不是染色树，而是普通树。

给定正整数n，<math>\rm tree(n)</math>被定义为满足以下条件的“树列”<math>\{T_n\}</math>的最大长度：

# <math>T_k</math>至多有<math>n+k</math>个顶点；
# 对于正整数<math>k<l</math>，<math>T_k</math>不能嵌入到<math>T_l</math>中。

== 有限性证明 ==
<math>\rm TREE(n)</math>和<math>\rm tree(n)</math>的序列总是有限的，这可由Kruskal树定理保证。

我们首先要引入'''良拟序(Well-quasi-ordering)'''的概念，它可以看成[[良序]]在一般[[良序#偏序集|偏序集]]上的推广。

设<math>(X,\le)</math>为一偏序集，若对于<math>X</math>中任意无穷序列<math>x_0,x_1,x_2,\cdots</math>，总存在<math>i<j</math>使得<math>x_i\le x_j</math>，则称<math>\le</math>为集合<math>X</math>上的一个良拟序。

换句话说，若偏序集中不存在“无穷降链”，也不存在“无穷不可比较链”，则称该偏序为一个良拟序。

Kruskal树定理说明，树的嵌入关系是一个良拟序。

也就是说，任意无限棵树构成的序列中，必存在两棵树，前面的树能嵌入到后面的树中。这就证明了<math>\rm tree(n)</math>的有限性。

== 取值 ==

=== n较小时 ===
对于<math>\rm TREE(n)</math>，有：

<math>\rm TREE(1)=1</math>

<math>\rm TREE(2)=3</math>

对于<math>\rm tree(n)</math>，有：

<math>\rm tree(1)=2</math>

<math>\rm tree(2)=5</math>

<math>{\rm tree(3)\geq844,424,930,131,960}</math>

=== TREE(3) ===
[[文件:TREE(3).jpg|缩略图]]
和<math>\rm TREE(1)</math>、<math>\rm TREE(2)</math>仅有一位数的取值相比，<math>\rm TREE(3)</math>的值出现了“暴涨”，其远远超过了[[葛立恒数]]和[[Kirby-Paris Hydra|Hydra(5)]]，这使它成为大数领域中最著名的数字之一。

右图是<math>\rm TREE(3)</math>序列可能的前几项。

HypCos在这篇回答<ref>https://www.zhihu.com/question/353941713/answer/885942447</ref>中给出了<math>\rm TREE(3)</math>的一个下界：

\({\rm TREE(3)}>H_{\varphi(1@\omega,3)\cdot\varphi(1@\omega)}({\rm tree(tree(3)+1)})\)(其中H为[[增长层级#哈代层级|哈代层级]]，下同)

=== tree(4) ===
2025年5月24日，HypCos在这篇回答<ref>https://www.zhihu.com/question/1907086430552950742/answer/1909662327449584802</ref>中给出了<math>\rm tree(4)</math>的一个下界：<math>{\rm tree(4)}>H_{\varepsilon_{\omega^22+1}+\alpha}(2\uparrow\uparrow\uparrow6)</math>

== 增长率 ==
通过对树的嵌入关系进行编序(此处等待进一步说明)，我们可以得到<math>\rm TREE(n)</math>和<math>\rm tree(n)</math>的增长率分别为

\({\rm TREE(n)}\sim\varphi(\omega@\omega)\)

\({\rm tree(n)}\sim\varphi(1@\omega)\)
== 参考资料 ==
<references />
[[分类:记号]]

Catching

2025-07-15T19:48:20Z

Apocalypse：重写词条

'''追平(Catching)'''是googology中的一种现象。

== 定义 ==
'''注意：追平目前尚没有广泛认可的严格定义。以下定义仅供参考，并随时可能被新的理论修改。'''
=== [[序数记号]]之间的追平 ===
设<math>f</math>，<math>g</math>是两个将序数映射到序数的函数。如果存在某个序数<math>\alpha</math>，使得

<math>f(\alpha)\leq{g(\alpha)}<f(\alpha+1)</math>，

则称<math>f</math>和<math>g</math>在<math>\alpha</math>处追平，<math>\alpha</math>称为追平点。

==== 举例 ====
对于<math>f(\alpha)=\alpha</math>，<math>g(\alpha)=2\times\alpha</math>，

初看之下，似乎对于有限的<math>\alpha</math>，<math>g(\alpha)=2\times{f(\alpha)}</math>，随着<math>\alpha</math>越来越大，两者的差距应该越来越远。但是对于<math>\alpha=\omega</math>，我们有

<math>g(\omega)=2\times\omega=\omega=f(\omega)</math>，于是<math>f</math>和<math>g</math>在<math>\omega</math>处追平。

从这个例子中可以直观地感受“追平”：较大的序数“抹平”了其下的增长速度差异。

另外一个追平的例子是BOCF和MOCF，它们在[[HCO]]追平。

=== [[增长层级]]之间的追平 ===
理论上，可以把增长层级的每个函数都视为序数映射到序数的函数（只不过这里映射得到的一定是自然数），然后仿照上文定义。

不过我们在此给出另外一个定义：

对于两个增长层级<math>f_\alpha</math>和<math>g_\alpha</math>，如果对于某个序数<math>\beta</math>，

<math>f_\beta</math>在增长层级<math>g_\alpha</math>下的增长率为<math>\beta</math>，

则称<math>f_\alpha</math>和<math>g_\alpha</math>在<math>\beta</math>追平。

对于不同增长层级的追平关系，请参考[[增长层级#对照表|对照表]]。

燃烧数

2025-07-15T17:01:58Z

Apocalypse：/* 伪燃烧函数 */

'''燃烧数(Fusible number)'''，是一系列序型为<math>\varepsilon_0</math>的正有理数．

== 定义 ==
考虑以下的数学问题：一个人处于一个封闭的房间之中．他想要测量一段时间，但是房间之中没有钟表，只有一系列恰好能够在一小时内燃尽的绳索．这些绳索的燃烧速度是不均匀的，因此不能通过其长度来判断时间，但是可以通过将其两端全部点燃的方式测量一半的时间．现在想问：仅靠这些绳索，这个人可以在房间之中测量哪些时间？

这里所有能够测量出来的时间称为'''燃烧数'''．

可以证明：
如果<math>a</math>和<math>b</math>均为燃烧数，那么<math>(a+b+1)/2</math>也是燃烧数，并且由这个规则可以从<math>0</math>生成所有的燃烧数．

== 建立数学模型 ==

【待补充一些具体操作的例子】

为了研究燃烧数的问题，我们首先需要对其抽象，建立数学模型．每根绳子有两个末端．我们只允许以下两种操作：

* 在开始的时候（时刻为 <math>0</math>）点燃若干末端．
* 在一根绳子燃尽时点燃若干末端．

并有规定：若有绳子在 <math>t</math> 时刻燃尽，则 <math>t</math> 是燃烧数．

如果一根绳子的两端都被点燃，设其第一个末端的点燃时刻为 <math>t_1</math>，第二个末端的点燃时刻为 <math>t_2</math>，其中 <math>t_1,t_2</math> 都是燃烧数，且有 <math>0\le t_2-t_1<1</math>，那么不难算出这根绳子燃尽的时刻是 <math>(t_1+t_2+1)/2</math>．如果这根绳子只有一个末端被点燃，点燃时刻是 <math>t</math>，那么它燃尽的时刻就是 <math>t+1</math>．

综上，我们对燃烧数建立了清晰的认识：

* <math>0</math> 是燃烧数．
* 若 <math>a</math> 是燃烧数，则 <math>a+1</math> 是燃烧数．
* 若 <math>a,b</math> 是燃烧数且 <math>|b-a|<1</math>，则 <math>(a+b+1)/2</math> 是燃烧数．
* 所有燃烧数都能通过以上三种方式产生．

从上面第三条可以看出，若 <math>a</math> 是燃烧数，取 <math>b=a</math>，则得到 <math>a+1/2</math> 也是燃烧数，进而 <math>a+1</math> 是燃烧数．这蕴含了上面第二条．所以上面的条件可以进一步精简为：

* <math>0</math> 是燃烧数．
* 若 <math>a,b</math> 是燃烧数且 <math>|b-a|<1</math>，则 <math>(a+b+1)/2</math> 是燃烧数．
* 所有燃烧数都能通过以上两种方式产生．

【待补充一些具体计算的例子】

== 伪燃烧函数 ==

定义函数 <math>f:\R\to\R</math> 为：<math>f(x)</math> 表示 <math>x</math> 到下一个燃烧数的距离．例如，<math>1/3</math> 的下一个燃烧数是 <math>1/2</math>，所以 <math>f(1/3)=1/2-1/3=1/6</math>．

显然，若 <math>x<0</math>，则 <math>x</math> 的下一个燃烧数是 <math>0</math>，所以 <math>f(x)=-x</math>．

若 <math>x\ge 0</math>，则 <math>x</math> 的下一个燃烧数是 <math>(a+b+1)/2>x</math>，其中 <math>a,b</math> 是燃烧数，且 <math>|b-a|<1</math>．

所以 <math>2x<a+b+1\le a+(a+1)+1=2(a+1)</math>，即 <math>a>x-1</math>．

然而，<math>a</math> 是否就是 <math>x-1</math> 之后的第一个燃烧数呢？其实不一定，不过我们假设如此．这样得到的结果其实已经不是真实的燃烧数，我们叫它“伪燃烧数”．我们假设 <math>a=x-1+f(x-1)</math>．

接下来考虑 <math>b</math>．现在对 <math>b</math> 有两个限制，其一是 <math>b>a-1</math>，其二是 <math>(a+b+1)/2>x</math>．后者即为 <math>b>2x-1-a</math>．因为 <math>a<x</math>，所以 <math>2x-1-a>2a-1-a=a-1</math>，也就是说第二条比第一条更强，我们只需考虑第二条限制 <math>b>2x-1-a</math> 即可．

在确定了 <math>a</math> 之后，为了找到大于 <math>x</math> 的最小燃烧数，我们应该让 <math>b</math> 尽可能小，让 <math>b</math> 是 <math>2x-1-a</math> 后的第一个燃烧数，即 <math>b=2x-1-a+f(2x-1-a)</math>．

有了以上的分析，我们就可以算出 <math>f(x)</math> 了：

<math display=block>\begin{aligned}
f(x)\,&=(a+b+1)/2-x\\
&=(a+2x-1-a+f(2x-1-a)+1)/2-x\\
&=f(2x-1-a)/2\\
&=f(2x-1-(x-1+f(x-1)))/2\\
&=f(x-f(x-1))/2
\end{aligned}</math>

综上，

<math display=block>f(x)=\begin{cases}-x&x<0\\ \dfrac 12 f(x-f(x-1))&x\ge 0\end{cases}</math>

这就是伪燃烧函数．

有了上述迭代公式，我们可以尝试直接计算较小的<math>f(n)</math>．我们有

<math>f(0)=\frac{1}{2}f(0-f(0-1))=\frac{1}{2}f(-f(-1))=\frac{1}{2}f(-1)=\frac{1}{2}\times1=\frac{1}{2}</math>，

<math>f(1)=\frac{1}{2}f(1-f(1-1))=\frac{1}{2}f(1-f(0))=\frac{1}{2}f(1-\frac{1}{2})=\frac{1}{2}f(\frac{1}{2})=\frac{1}{4}f(\frac{1}{2}-f(\frac{1}{2}-1))=\frac{1}{4}f(\frac{1}{2}-f(-\frac{1}{2}))=\frac{1}{4}f(\frac{1}{2}-\frac{1}{2})=\frac{1}{4}f(0)=\frac{1}{8}</math>．

对于<math>n=2</math>，可以算出

<math>f(2)=\frac{1}{1024}</math>

对于更大的<math>n</math>，为了简化计算，我们需要定义以下概念：

设<math>A_\alpha</math>是从小到大第<math>\alpha</math>个燃烧数(0是第1个)，<math>d(\alpha)=-log_2f(A_\alpha)</math>，规定<math>d(0)=0</math>．

我们可以证明<ref>https://zhuanlan.zhihu.com/p/1908578056337076774</ref><math>d(\alpha)</math>满足如下递推关系：

# <math>d(\alpha+1)=1+d(\alpha)</math>
# <math>d(\omega^\alpha\times{(k+1)}+\beta)=k+d(\omega^\alpha+\beta)</math>，<math>\beta<\omega^\alpha</math>
# <math>d(\omega^{\alpha+1}+\beta)=2+d(\omega^\alpha+\beta)</math>，<math>\beta<\omega^{\alpha+1}</math>
# <math>d(\omega^\alpha+\beta)=1+d(\omega^{\alpha[\chi(\alpha)]}+\beta)</math>，<math>\beta<\omega^\alpha</math>

其中<math>\chi(\alpha)</math>满足如下递推关系：

# <math>\chi(\omega^\alpha\times{(k+1)}+\beta)=\chi(\omega^\alpha+\beta)</math>，<math>k\geq1</math>，<math>\beta<\omega^\alpha</math>为极限序数
#<math>\chi(\omega^\alpha+\beta)=\chi(\omega^{\alpha[\chi(\alpha)]}+\beta)</math>，<math>\alpha</math>，<math>\beta</math>为极限序数，<math>\beta<\omega^\alpha</math>，<math>\beta\neq\omega^{\alpha[\chi(\alpha)]+1}</math>
#<math>\chi(\omega^\alpha+\omega^{\alpha[\chi(\alpha)]+1})=\chi(\omega^{\alpha[\chi(\alpha)]+1})-1</math>，<math>\alpha</math>为极限序数
# <math>\chi(\omega^{\alpha+1}+\beta)=\chi(\omega^\alpha\times2+\beta)</math>，<math>\beta<\omega^{\alpha+1}</math>为极限序数
# <math>\chi(\omega^{\alpha+1}\times{(k+1)})=\chi(\omega^{\alpha+1})-2</math>，<math>k\geq1</math>
# <math>\chi(\omega^{\alpha+1})=d(\omega^{\alpha+1})-d(\alpha)+1</math>
#<math>\chi(\omega^\alpha\times{k})=d(\omega^\alpha)-d(\alpha)+\chi(\alpha)</math>，<math>k\geq1</math>，<math>\alpha</math>为极限序数

其中<math>\alpha[n]</math>代表其基本列．据此可以计算<ref>https://www.zhihu.com/question/36464952/answer/2912411355</ref><math>f(3)</math>的取值：

<math>f(3)=\frac{1}{2^{1541023937}}</math>。

通过一些技巧，也可以不使用序数直接计算出<math>f(3)</math><ref>https://zhuanlan.zhihu.com/p/26493979529</ref>．

（等待更新）

== 参见 ==

[https://www.zhihu.com/question/36464952/answer/2912411355 Achatinidae 的知乎回答]

<references />

[[分类:记号]]

燃烧数

2025-07-14T22:58:39Z

Apocalypse：伪燃烧数内容补充

'''燃烧数(Fusible number)'''，是一系列序型为<math>\varepsilon_0</math>的正有理数．

== 定义 ==
考虑以下的数学问题：一个人处于一个封闭的房间之中．他想要测量一段时间，但是房间之中没有钟表，只有一系列恰好能够在一小时内燃尽的绳索．这些绳索的燃烧速度是不均匀的，因此不能通过其长度来判断时间，但是可以通过将其两端全部点燃的方式测量一半的时间．现在想问：仅靠这些绳索，这个人可以在房间之中测量哪些时间？

这里所有能够测量出来的时间称为'''燃烧数'''．

可以证明：
如果<math>a</math>和<math>b</math>均为燃烧数，那么<math>(a+b+1)/2</math>也是燃烧数，并且由这个规则可以从<math>0</math>生成所有的燃烧数．

== 建立数学模型 ==

【待补充一些具体操作的例子】

为了研究燃烧数的问题，我们首先需要对其抽象，建立数学模型．每根绳子有两个末端．我们只允许以下两种操作：

* 在开始的时候（时刻为 <math>0</math>）点燃若干末端．
* 在一根绳子燃尽时点燃若干末端．

并有规定：若有绳子在 <math>t</math> 时刻燃尽，则 <math>t</math> 是燃烧数．

如果一根绳子的两端都被点燃，设其第一个末端的点燃时刻为 <math>t_1</math>，第二个末端的点燃时刻为 <math>t_2</math>，其中 <math>t_1,t_2</math> 都是燃烧数，且有 <math>0\le t_2-t_1<1</math>，那么不难算出这根绳子燃尽的时刻是 <math>(t_1+t_2+1)/2</math>．如果这根绳子只有一个末端被点燃，点燃时刻是 <math>t</math>，那么它燃尽的时刻就是 <math>t+1</math>．

综上，我们对燃烧数建立了清晰的认识：

* <math>0</math> 是燃烧数．
* 若 <math>a</math> 是燃烧数，则 <math>a+1</math> 是燃烧数．
* 若 <math>a,b</math> 是燃烧数且 <math>|b-a|<1</math>，则 <math>(a+b+1)/2</math> 是燃烧数．
* 所有燃烧数都能通过以上三种方式产生．

从上面第三条可以看出，若 <math>a</math> 是燃烧数，取 <math>b=a</math>，则得到 <math>a+1/2</math> 也是燃烧数，进而 <math>a+1</math> 是燃烧数．这蕴含了上面第二条．所以上面的条件可以进一步精简为：

* <math>0</math> 是燃烧数．
* 若 <math>a,b</math> 是燃烧数且 <math>|b-a|<1</math>，则 <math>(a+b+1)/2</math> 是燃烧数．
* 所有燃烧数都能通过以上两种方式产生．

【待补充一些具体计算的例子】

== 伪燃烧函数 ==

定义函数 <math>f:\R\to\R</math> 为：<math>f(x)</math> 表示 <math>x</math> 到下一个燃烧数的距离．例如，<math>1/3</math> 的下一个燃烧数是 <math>1/2</math>，所以 <math>f(1/3)=1/2-1/3=1/6</math>．

显然，若 <math>x<0</math>，则 <math>x</math> 的下一个燃烧数是 <math>0</math>，所以 <math>f(x)=-x</math>．

若 <math>x\ge 0</math>，则 <math>x</math> 的下一个燃烧数是 <math>(a+b+1)/2>x</math>，其中 <math>a,b</math> 是燃烧数，且 <math>|b-a|<1</math>．

所以 <math>2x<a+b+1\le a+(a+1)+1=2(a+1)</math>，即 <math>a>x-1</math>．

然而，<math>a</math> 是否就是 <math>x-1</math> 之后的第一个燃烧数呢？其实不一定，不过我们假设如此．这样得到的结果其实已经不是真实的燃烧数，我们叫它“伪燃烧数”．我们假设 <math>a=x-1+f(x-1)</math>．

接下来考虑 <math>b</math>．现在对 <math>b</math> 有两个限制，其一是 <math>b>a-1</math>，其二是 <math>(a+b+1)/2>x</math>．后者即为 <math>b>2x-1-a</math>．因为 <math>a<x</math>，所以 <math>2x-1-a>2a-1-a=a-1</math>，也就是说第二条比第一条更强，我们只需考虑第二条限制 <math>b>2x-1-a</math> 即可．

在确定了 <math>a</math> 之后，为了找到大于 <math>x</math> 的最小燃烧数，我们应该让 <math>b</math> 尽可能小，让 <math>b</math> 是 <math>2x-1-a</math> 后的第一个燃烧数，即 <math>b=2x-1-a+f(2x-1-a)</math>．

有了以上的分析，我们就可以算出 <math>f(x)</math> 了：

<math display=block>\begin{aligned}
f(x)\,&=(a+b+1)/2-x\\
&=(a+2x-1-a+f(2x-1-a)+1)/2-x\\
&=f(2x-1-a)/2\\
&=f(2x-1-(x-1+f(x-1)))/2\\
&=f(x-f(x-1))/2
\end{aligned}</math>

综上，

<math display=block>f(x)=\begin{cases}-x&x<0\\ \dfrac 12 f(x-f(x-1))&x\ge 0\end{cases}</math>

这就是伪燃烧函数．

有了上述迭代公式，我们可以尝试直接计算较小的<math>f(n)</math>．我们有

<math>f(0)=\frac{1}{2}f(0-f(0-1))=\frac{1}{2}f(-f(-1))=\frac{1}{2}f(-1)=\frac{1}{2}\times1=\frac{1}{2}</math>，

<math>f(1)=\frac{1}{2}f(1-f(1-1))=\frac{1}{2}f(1-f(0))=\frac{1}{2}f(1-\frac{1}{2})=\frac{1}{2}f(\frac{1}{2})=\frac{1}{4}f(\frac{1}{2}-f(\frac{1}{2}-1))=\frac{1}{4}f(\frac{1}{2}-f(-\frac{1}{2}))=\frac{1}{4}f(\frac{1}{2}-\frac{1}{2})=\frac{1}{4}f(0)=\frac{1}{8}</math>．

对于<math>n=2</math>，可以算出

<math>f(2)=\frac{1}{1024}</math>

对于更大的<math>n</math>，为了简化计算，我们需要定义以下概念：

设<math>A_\alpha</math>是从小到大第<math>\alpha</math>个燃烧数，<math>d(\alpha)=-log_2f(A_\alpha)</math>．

我们可以证明<ref>https://zhuanlan.zhihu.com/p/1908578056337076774</ref><math>d(\alpha)</math>满足如下递推关系：

# <math>d(\alpha+1)=1+d(\alpha)</math>
# <math>d(\omega^\alpha\times{(k+1)}+\beta)=k+d(\omega^\alpha+\beta)</math>，<math>\beta<\omega^\alpha</math>
# <math>d(\omega^{\alpha+1}+\beta)=2+d(\omega^\alpha+\beta)</math>，<math>\beta<\omega^{\alpha+1}</math>
# <math>d(\omega^\alpha+\beta)=1+d(\omega^{\alpha[\chi(\alpha)]}+\beta)</math>，<math>\beta<\omega^\alpha</math>

其中<math>\chi(\alpha)</math>满足如下递推关系：

# <math>\chi(\omega^\alpha\times{(k+1)}+\beta)=\chi(\omega^\alpha+\beta)</math>，<math>k\geq1</math>，<math>\beta<\omega^\alpha</math>为极限序数
#<math>\chi(\omega^\alpha+\beta)=\chi(\omega^{\alpha[\chi(\alpha)]}+\beta)</math>，<math>\alpha</math>，<math>\beta</math>为极限序数，<math>\beta<\omega^\alpha</math>，<math>\beta\neq\omega^{\alpha[\chi(\alpha)]+1}</math>
#<math>\chi(\omega^\alpha+\omega^{\alpha[\chi(\alpha)]+1})=\chi(\omega^{\alpha[\chi(\alpha)]+1})-1</math>，<math>\alpha</math>为极限序数
# <math>\chi(\omega^{\alpha+1}+\beta)=\chi(\omega^\alpha\times2+\beta)</math>，<math>\beta<\omega^{\alpha+1}</math>为极限序数
# <math>\chi(\omega^{\alpha+1}\times{(k+1)})=\chi(\omega^{\alpha+1})-2</math>，<math>k\geq1</math>
# <math>\chi(\omega^{\alpha+1})=d(\omega^{\alpha+1})-d(\alpha)+1</math>
#<math>\chi(\omega^\alpha\times{k})=d(\omega^\alpha)-d(\alpha)+\chi(\alpha)</math>，<math>k\geq1</math>，<math>\alpha</math>为极限序数

其中<math>\alpha[n]</math>代表其基本列．据此可以计算<ref>https://www.zhihu.com/question/36464952/answer/2912411355</ref><math>f(3)</math>的取值：

<math>f(3)=\frac{1}{2^{1541023937}}</math>。

通过一些技巧，也可以不使用序数直接计算出<math>f(3)</math><ref>https://zhuanlan.zhihu.com/p/26493979529</ref>．

（等待更新）

== 参见 ==

[https://www.zhihu.com/question/36464952/answer/2912411355 Achatinidae 的知乎回答]

<references />

[[分类:记号]]

BMS分析

2025-07-14T20:47:32Z

Apocalypse：/* 4： (0)(1,1,1)(2,1,0)~(0)(1,1,1)(2,1,1) */

目前使用的OCF为M型，后续补充BOCF

==== 1：单行BMS（PrSS） ====
<math>\varnothing=0</math>

<math>(0)=1</math>

<math>(0)(0)=2</math>

<math>(0)(0)(0)=3</math>

<math>(0)(1)=(0)(0)(0)(0)(0)...=\omega</math>

<math>(0)(1)(0)=\omega+1</math>

<math>(0)(1)(0)(0)=\omega+2</math>

<math>(0)(1)(0)(1)=\omega\times2</math>

<math>(0)(1)(0)(1)(0)(1)=\omega\times3</math>

<math>(0)(1)(1)=(0)(1)(0)(1)(0)(1)...=\omega^2</math>

<math>(0)(1)(1)(0)=\omega^2+1</math>

<math>(0)(1)(1)(0)(1)=\omega^2+\omega</math>

<math>(0)(1)(1)(0)(1)(0)(1)=\omega^2+\omega\times2</math>

<math>(0)(1)(1)(0)(1)(1)=\omega^2\times2</math>

<math>(0)(1)(1)(0)(1)(1)(0)(1)=\omega^2\times2+\omega</math>

<math>(0)(1)(1)(0)(1)(1)(0)(1)(1)=\omega^2\times3</math>

<math>(0)(1)(1)(1)=\omega^3</math>

<math>(0)(1)(1)(1)(1)=\omega^4</math>

<math>(0)(1)(2)=(0)(1)(1)(1)(1)...=\omega^\omega</math>

<math>(0)(1)(2)(0)(1)(2)=\omega^\omega\times2</math>

<math>(0)(1)(2)(1)=\omega^{\omega+1}</math>

<math>(0)(1)(2)(1)(1)=\omega^{\omega+2}</math>

<math>(0)(1)(2)(1)(1)(1)=\omega^{\omega+3}</math>

<math>(0)(1)(2)(1)(2)=\omega^{\omega\times2}</math>

<math>(0)(1)(2)(1)(2)(1)(2)=\omega^{\omega\times3}</math>

<math>(0)(1)(2)(2)=\omega^{\omega^2}</math>

<math>(0)(1)(2)(2)(1)=\omega^{\omega^2+1}</math>

<math>(0)(1)(2)(2)(1)(2)=\omega^{\omega^2+\omega}</math>

<math>(0)(1)(2)(2)(1)(2)(2)=\omega^{\omega^2\times2}</math>

<math>(0)(1)(2)(2)(1)(2)(2)(1)(2)(2)=\omega^{\omega^2\times3}</math>

<math>(0)(1)(2)(2)(2)=\omega^{\omega^3}</math>

<math>(0)(1)(2)(2)(2)(2)=\omega^{\omega^4}</math>

<math>(0)(1)(2)(3)=(0)(1)(2)(2)(2)(2)...=\omega^{\omega^\omega}</math>

<math>(0)(1)(2)(3)(4)=\omega^{\omega^{\omega^\omega}}</math>

<math>(0)(1)(2)(3)(4)(5)=\omega^{\omega^{\omega^{\omega^\omega}}}</math>

<math>(0)(1,1)=(0)(1)(2)(3)(4)(5)(6)...=\varepsilon_0</math>

==== 2：双行BMS ====
{| class="wikitable"
|-
! BMS !! Veblen !! MOCF
|-
| <math>(0)(1,1)</math>|| <math>\varepsilon_0</math>
|-
| <math>(0)(1,1)(0,0)</math>|| <math>\varepsilon_0+1</math>
|-
| <math>(0)(1,1)(0,0)(1,0)</math>|| <math>\varepsilon_0+\omega</math>
|-
| <math>(0)(1,1)(0,0)(1,1)</math>|| <math>\varepsilon_0\times2</math>
|-
| <math>(0)(1,1)(0,0)(1,1)(0,0)(1,1)</math>|| <math>\varepsilon_0\times3</math>
|-
| <math>(0)(1,1)(1,0)</math>|| <math>\varepsilon_0\times\omega</math>
|-
| <math>(0)(1,1)(1,0)(1,0)</math>|| <math>\varepsilon_0\times\omega^2</math>
|-
| <math>(0)(1,1)(1,0)(2,0)</math>|| <math>\varepsilon_0\times\omega^\omega</math>
|-
| <math>(0)(1,1)(1,0)(2,0)(3,0)</math>|| <math>\varepsilon_0\times\omega^{\omega^\omega}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)</math>|| <math>\varepsilon_0^2</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(1,0)(2,0)</math>|| <math>\varepsilon_0^2\times\omega</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(1,0)(2,0)(3,0)</math>|| <math>\varepsilon_0^2\times\omega^\omega</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(1,0)(2,1)</math>|| <math>\varepsilon_0^3</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(1,0)(2,1)(1,0)(2,1)</math>|| <math>\varepsilon_0^4</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)</math>|| <math>\varepsilon_0^\omega</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(1,0)(2,1)</math>|| <math>\varepsilon_0^{\omega+1}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(1,0)(2,1)(1,0)(2,1)</math>|| <math>\varepsilon_0^{\omega+2}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(1,0)(2,1)(2,0)</math>|| <math>\varepsilon_0^{\omega\times2}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(1,0)(2,1)(2,0)(1,0)(2,1)(2,0)</math>|| <math>\varepsilon_0^{\omega\times3}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(2,0)</math>|| <math>\varepsilon_0^{\omega^2}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(3,0)</math>|| <math>\varepsilon_0^{\omega^\omega}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(3,0)(4,0)</math>|| <math>\varepsilon_0^{\omega^{\omega^\omega}}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(3,1)</math>|| <math>\varepsilon_0^{\varepsilon_0}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(3,1)(3,0)(4,1)</math>|| <math>\varepsilon_0^{\varepsilon_0^{\varepsilon_0}}</math>
|-
| <math>(0)(1,1)(1,0)(2,1)(2,0)(3,1)(3,0)(4,1)(4,0)(5,1)</math>|| <math>\varepsilon_0^{\varepsilon_0^{\varepsilon_0^{\varepsilon_0}}}</math>
|-
| <math>(0)(1,1)(1,1)</math>|| <math>\varepsilon_1</math>
|-
| <math>(0)(1,1)(1,1)(0,0)(1,1)(1,1)</math>|| <math>\varepsilon_1\times2</math>
|-
| <math>(0)(1,1)(1,1)(1,0)</math>|| <math>\varepsilon_1\times\omega</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)</math>|| <math>\varepsilon_1\times\varepsilon_0</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,0)(3,1)</math>|| <math>\varepsilon_1\times\varepsilon_0^2</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,0)(3,1)(3,0)(4,1)</math>|| <math>\varepsilon_1\times\varepsilon_0^{\varepsilon_0}</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,1)</math>|| <math>\varepsilon_1^2</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,1)(2,0)</math>|| <math>\varepsilon_1^\omega</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,1)(2,0)(3,1)</math>|| <math>\varepsilon_1^{\varepsilon_0}</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,1)(2,0)(3,1)(3,1)</math>|| <math>\varepsilon_1^{\varepsilon_1}</math>
|-
| <math>(0)(1,1)(1,1)(1,0)(2,1)(2,1)(2,0)(3,1)(3,1)(3,0)(4,1)(4,1)</math>|| <math>\varepsilon_1^{\varepsilon_1^{\varepsilon_1}}</math>
|-
| <math>(0)(1,1)(1,1)(1,1)</math>|| <math>\varepsilon_2</math>
|-
| <math>(0)(1,1)(1,1)(1,1)(1,1)</math>|| <math>\varepsilon_3</math>
|-
| <math>(0)(1,1)(2,0)</math>|| <math>\varepsilon_\omega</math>
|-
| <math>(0)(1,1)(2,0)(1,0)</math>|| <math>\varepsilon_\omega\times\omega</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)</math>|| <math>\varepsilon_\omega\times\varepsilon_0</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)(2,1)</math>|| <math>\varepsilon_\omega\times\varepsilon_1</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)(2,1)(2,1)</math>|| <math>\varepsilon_\omega\times\varepsilon_2</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)(2,1)(2,1)(2,1)</math>|| <math>\varepsilon_\omega\times\varepsilon_3</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)(3,0)</math>|| <math>\varepsilon_\omega^2</math>
|-
| <math>(0)(1,1)(2,0)(1,0)(2,1)(3,0)(2,0)(3,1)(4,0)</math>|| <math>\varepsilon_\omega^{\varepsilon_\omega}</math>
|-
| <math>(0)(1,1)(2,0)(1,1)</math>|| <math>\varepsilon_{\omega+1}</math>
|-
| <math>(0)(1,1)(2,0)(1,1)(1,1)</math>|| <math>\varepsilon_{\omega+2}</math>
|-
| <math>(0)(1,1)(2,0)(1,1)(1,1)(1,1)</math>|| <math>\varepsilon_{\omega+3}</math>
|-
| <math>(0)(1,1)(2,0)(1,1)(2,0)</math>|| <math>\varepsilon_{\omega\times2}</math>
|-
| <math>(0)(1,1)(2,0)(1,1)(2,0)(1,1)(2,0)</math>|| <math>\varepsilon_{\omega\times3}</math>
|-
| <math>(0)(1,1)(2,0)(2,0)</math>|| <math>\varepsilon_{\omega^2}</math>
|-
| <math>(0)(1,1)(2,0)(2,0)(2,0)</math>|| <math>\varepsilon_{\omega^3}</math>
|-
| <math>(0)(1,1)(2,0)(3,0)</math>|| <math>\varepsilon_{\omega^\omega}</math>
|-
| <math>(0)(1,1)(2,0)(3,0)(4,0)</math>|| <math>\varepsilon_{\omega^{\omega^\omega}}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)</math>|| <math>\varepsilon_{\varepsilon_0}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)(1,1)</math>|| <math>\varepsilon_{\varepsilon_0+1}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)(3,1)</math>|| <math>\varepsilon_{\varepsilon_1}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)(4,0)</math>|| <math>\varepsilon_{\varepsilon_\omega}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)(4,0)(5,1)</math>|| <math>\varepsilon_{\varepsilon_{\varepsilon_0}}</math>
|-
| <math>(0)(1,1)(2,0)(3,1)(4,0)(5,1)(6,0)(7,1)</math>|| <math>\varepsilon_{\varepsilon_{\varepsilon_{\varepsilon_0}}}</math>
|-
| <math>(0)(1,1)(2,1)</math>|| <math>\zeta_0</math>
|-
| <math>(0)(1,1)(2,1)(1,0)(2,1)(3,1)</math>|| <math>\zeta_0^2</math>
|-
| <math>(0)(1,1)(2,1)(1,0)(2,1)(3,1)(2,0)(3,1)(4,1)</math>|| <math>\zeta_0^{\zeta_0}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)</math>|| <math>\varepsilon_{\zeta_0+1}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(1,0)(2,1)(3,1)(2,1)</math>|| <math>\varepsilon_{\zeta_0+1}^2</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(1,1)</math>|| <math>\varepsilon_{\zeta_0+2}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)</math>|| <math>\varepsilon_{\zeta_0+\omega}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)(3,1)</math>|| <math>\varepsilon_{\zeta_0+\varepsilon_0}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)(3,1)(4,1)</math>|| <math>\varepsilon_{\zeta_0\times2}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)(3,1)(4,1)(3,1)</math>|| <math>\varepsilon_{\varepsilon_{\zeta_0+1}}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)(3,1)(4,1)(3,1)(4,0)(5,1)(6,1)(5,1)</math>|| <math>\varepsilon_{\varepsilon_{\varepsilon_{\zeta+1}}}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,1)</math>|| <math>\zeta_1</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,1)(1,1)</math>|| <math>\varepsilon_{\zeta_1+1}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,0)</math>|| <math>\varepsilon_{\zeta_1+\omega}</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,1)(1,1)(2,1)</math>|| <math>\zeta_2</math>
|-
| <math>(0)(1,1)(2,1)(1,1)(2,1)(1,1)(2,1)(1,1)(2,1)</math>|| <math>\zeta_3</math>
|-
| <math>(0)(1,1)(2,1)(2,0)</math>|| <math>\zeta_\omega</math>
|-
| <math>(0)(1,1)(2,1)(2,0)(2,0)</math>|| <math>\zeta_{\omega^2}</math>
|-
| <math>(0)(1,1)(2,1)(2,0)(3,1)</math>|| <math>\zeta_{\varepsilon_0}</math>
|-
| <math>(0)(1,1)(2,1)(2,0)(3,1)(4,1)</math>|| <math>\zeta_{\zeta_0}</math>
|-
| <math>(0)(1,1)(2,1)(2,0)(3,1)(4,1)(4,0)(5,1)(6,1)</math>|| <math>\zeta_{\zeta_{\zeta_0}}</math>
|-
| <math>(0)(1,1)(2,1)(2,1)</math>|| <math>\eta_0</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(1,1)</math>|| <math>\varepsilon_{\eta_0+1}</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(1,1)(2,1)</math>|| <math>\zeta_{\eta_0+1}</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2,0)(3,1)(4,1)(4,1)(3,1)(4,1)</math>|| <math>\zeta_{\zeta_{\eta_0+1}}</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2,1)</math>|| <math>\eta_1</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2,1)(1,1)(2,1)(2,1)</math>|| <math>\eta_2</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(2,0)</math>|| <math>\eta_\omega</math>
|-
| <math>(0)(1,1)(2,1)(2,1)(2,1)</math>|| <math>\varphi(4,0)</math>|| <math>\psi(\Omega^3)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)</math>|| <math>\varphi(\omega,0)</math>|| <math>\psi(\Omega^\omega)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(1,1)</math>|| <math>\varphi(1,\varphi(\omega,0)+1)</math>|| <math>\psi(\Omega^\omega+1)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(1,1)(2,1)</math>|| <math>\varphi(2,\varphi(\omega,0)+1)</math>|| <math>\psi(\Omega^\omega+\Omega)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(1,1)(2,1)(2,1)</math>|| <math>\varphi(3,\varphi(\omega,0)+1)</math>|| <math>\psi(\Omega^\omega+\Omega^2)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(1,1)(2,1)(3,0)</math>|| <math>\varphi(\omega,1)</math>|| <math>\psi(\Omega^\omega\times2)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(1,1)(2,1)(3,0)(1,1)(2,1)(3,0)</math>|| <math>\varphi(\omega,2)</math>|| <math>\psi(\Omega^\omega\times3)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,0)</math>|| <math>\varphi(\omega,\omega)</math>|| <math>\psi(\Omega^\omega\times\omega)</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,1)</math>|| <math>\varphi(\omega+1,0)</math>|| <math>\psi(\Omega^{\omega+1})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,1)(2,1)</math>|| <math>\varphi(\omega+2,0)</math>|| <math>\psi(\Omega^{\omega+2})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,1)(2,1)(2,1)</math>|| <math>\varphi(\omega+3,0)</math>|| <math>\psi(\Omega^{\omega+3})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,1)(3,0)</math>|| <math>\varphi(\omega\times2,0)</math>|| <math>\psi(\Omega^{\omega\times2})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(2,1)(3,0)(2,1)(3,0)</math>|| <math>\varphi(\omega\times3,0)</math>|| <math>\psi(\Omega^{\omega\times3})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(3,0)</math>|| <math>\varphi(\omega^2,0)</math>|| <math>\psi(\Omega^{\omega^2})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(4,1)</math>|| <math>\varphi(\varphi(1,0),0)</math>|| <math>\psi(\Omega^{\psi(0)})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(4,1)(5,1)</math>|| <math>\varphi(\varphi(2,0),0)</math>|| <math>\psi(\Omega^{\psi(\Omega)})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(4,1)(5,1)(6,0)</math>|| <math>\varphi(\varphi(\omega,0),0)</math>|| <math>\psi(\Omega^{\psi(\Omega^\omega)})</math>
|-
| <math>(0)(1,1)(2,1)(3,0)(4,1)(5,1)(6,0)(7,1)(8,1)(9,0)</math>|| <math>\varphi(\varphi(\varphi(\omega,0),0),0)</math>|| <math>\psi(\Omega^{\psi(\Omega^{\psi(\Omega^\omega)})})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)</math>|| <math>\varphi(1,0,0)=\Gamma_0</math>|| <math>\psi(\Omega^\Omega)</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(1,1)(2,1)(3,1)</math>|| <math>\varphi(1,0,1)=\Gamma_1</math>|| <math>\psi(\Omega^\Omega\times2)</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(1,1)(2,1)(3,1)(1,1)(2,1)(3,1)</math>|| <math>\varphi(1,0,2)=\Gamma_2</math>|| <math>\psi(\Omega^\Omega\times3)</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,0)</math>|| <math>\varphi(1,0,\omega)=\Gamma_\omega</math>|| <math>\psi(\Omega^\Omega\times\omega)</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,0)(3,1)(4,1)(5,1)</math>|| <math>\varphi(1,0,\varphi(1,0,0))=\Gamma_{\Gamma_0}</math>|| <math>\psi(\Omega^\Omega\times\psi(\Omega^\Omega))</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,0)(3,1)(4,1)(5,1)(4,0)(5,1)(6,1)(7,1)</math>|| <math>\varphi(1,0,\varphi(1,0,\varphi(1,0,0)))=\Gamma_{\Gamma_{\Gamma_0}}</math>|| <math>\psi(\Omega^\Omega\times\psi(\Omega^\Omega\times\psi(\Omega^\Omega)))</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)</math>|| <math>\varphi(1,1,0)</math>|| <math>\psi(\Omega^{\Omega+1})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)(2,1)</math>|| <math>\varphi(1,2,0)</math>|| <math>\psi(\Omega^{\Omega+2})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)(3,0)</math>|| <math>\varphi(1,\omega,0)</math>|| <math>\psi(\Omega^{\Omega+\omega})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)(3,0)(4,1)(5,1)(6,1)(5,1)(6,0)</math>|| <math>\varphi(1,\varphi(1,\omega,0),0)</math>|| <math>\psi(\Omega^{\Omega+\psi(\Omega^{\Omega+\omega})})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)(3,1)</math>|| <math>\psi(2,0,0)</math>|| <math>\psi(\Omega^{\Omega\times2})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(2,1)(3,1)(2,1)(3,1)</math>|| <math>\psi(3,0,0)</math>|| <math>\psi(\Omega^{\Omega\times3})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(3,0)</math>|| <math>\varphi(\omega,0,0)</math>|| <math>\psi(\Omega^{\Omega\times\omega})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(3,1)</math>|| <math>\varphi(1,0,0,0)</math>|| <math>\psi(\Omega^{\Omega^2})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(3,1)(3,1)</math>|| <math>\varphi(1,0,0,0,0)</math>|| <math>\psi(\Omega^{\Omega^3})</math>
|}

{| class="wikitable"
|-
! BMS !! MOCF
|-
| <math>(0)(1,1)(2,1)(3,1)(4,0)</math>|| <math>\psi(\Omega^{\Omega^\omega})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(4,0)(5,1)</math>|| <math>\psi(\Omega^{\Omega^{\psi(0)}})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(4,0)(5,1)(6,1)</math>|| <math>\psi(\Omega^{\Omega^{\psi(\Omega)}})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(4,0)(5,1)(6,1)(7,1)</math>|| <math>\psi(\Omega^{\Omega^{\psi(\Omega^\Omega)}})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(4,1)</math>|| <math>\psi(\Omega^{\Omega^\Omega})</math>
|-
| <math>(0)(1,1)(2,1)(3,1)(4,1)(5,1)</math>|| <math>\psi(\Omega^{\Omega^{\Omega^\Omega}})</math>
|-
| <math>(0)(1,1)(2,2)</math>|| <math>\psi(\psi_1(0))</math>
|-
| <math>(0)(1,1)(2,2)(1,1)</math>|| <math>\psi(\psi_1(0)+1)</math>
|-
| <math>(0)(1,1)(2,2)(1,1)(2,1)</math>|| <math>\psi(\psi_1(0)+\Omega)</math>
|-
| <math>(0)(1,1)(2,2)(1,1)(2,1)(3,1)</math>|| <math>\psi(\psi_1(0)+\Omega^\Omega)</math>
|-
| <math>(0)(1,1)(2,2)(1,1)(2,2)</math>|| <math>\psi(\psi_1(0)\times2)</math>
|-
| <math>(0)(1,1)(2,2)(2,0)</math>|| <math>\psi(\psi_1(0)\times\omega)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)</math>|| <math>\psi(\psi_1(0)\times\Omega)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)(3,0)</math>|| <math>\psi(\psi_1(0)\times\Omega^\omega)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)(3,1)</math>|| <math>\psi(\psi_1(0)\times\Omega^\Omega)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)(3,2)</math>|| <math>\psi(\psi_1(0)^2)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)(3,2)(3,0)</math>|| <math>\psi(\psi_1(0)^\omega)</math>
|-
| <math>(0)(1,1)(2,2)(2,1)(3,2)(3,1)(4,2)</math>|| <math>\psi(\psi_1(0)^{\psi_1(0)})</math>
|-
| <math>(0)(1,1)(2,2)(2,2)</math>|| <math>\psi(\psi_1(1))</math>
|-
| <math>(0)(1,1)(2,2)(3,0)</math>|| <math>\psi(\psi_1(\omega))</math>
|-
| <math>(0)(1,1)(2,2)(3,1)(4,2)</math>|| <math>\psi(\psi_1(\psi_1(0)))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)</math>|| <math>\psi(\Omega_2)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(1,1)</math>|| <math>\psi(\Omega_2+\Omega)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(1,1)(2,2)</math>|| <math>\psi(\Omega_2+\psi_1(0))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(1,1)(2,2)(3,1)(4,2)</math>|| <math>\psi(\Omega_2+\psi_1(\psi_1(0)))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(1,1)(2,2)(3,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2)\times\omega)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,1)(3,2)(4,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2)^2)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,1)(3,2)(4,2)(3,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2)^\omega)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,1)(3,2)(4,2)(3,1)(4,2)(5,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2)^{\psi_1(\Omega_2)})</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+1))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\omega))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2)))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(3,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2)\times\omega))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(4,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2)^\omega))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(4,1)(5,2)(6,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2)^{\psi_1(\Omega_2)}))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(4,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2+1)))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(4,2)(5,0)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2+\omega)))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,1)(4,2)(5,2)(4,2)(5,0)(5,1)(6,2)(7,2)</math>|| <math>\psi(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2+\psi_1(\Omega_2))))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(2,2)(3,2)</math>|| <math>\psi(\Omega_2\times2)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(3,0)</math>|| <math>\psi(\Omega_2\times\omega)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(3,1)(4,2)(5,2)</math>|| <math>\psi(\Omega_2\times\psi_1(\Omega_2))</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(3,2)</math>|| <math>\psi(\Omega_2^2)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(4,0)</math>|| <math>\psi(\Omega_2^\omega)</math>
|-
| <math>(0)(1,1)(2,2)(3,2)(4,2)</math>|| <math>\psi(\Omega_2^{\Omega_2})</math>
|-
| <math>(0)(1,1)(2,2)(3,3)</math>|| <math>\psi(\psi_2(0))</math>
|-
| <math>(0)(1,1)(2,2)(3,3)(4,3)</math>|| <math>\psi(\Omega_3)</math>
|-
| <math>(0)(1,1)(2,2)(3,3)(4,4)</math>|| <math>\psi(\psi_3(0))</math>
|-
| <math>(0)(1,1,1)=(0)(1,1)(2,2)(3,3)\cdots</math>|| <math>\psi(\Omega_\omega)</math>
|}

==== 3：三行BMS (0)(1,1,1)~(0)(1,1,1)(2,1,0) ====
三行之后BMS的行为复杂度急剧上升，因此部分节点的分析可能不会较为详细。

{| class="wikitable"
|-
! BMS !! MOCF
|-
| <math>(0)(1,1,1)</math>|| <math>\psi(\Omega_\omega)</math>
|-
| <math>(0)(1,1,1)(1,1,0)</math>|| <math>\psi(\Omega_\omega+1)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,0,0)</math>|| <math>\psi(\Omega_\omega+\omega)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,1,0)</math>|| <math>\psi(\Omega_\omega+\Omega)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(0))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(2,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(1))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\omega))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,1,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\psi_1(0)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,0,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2)\times\omega)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,1,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2)^\omega)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2+1))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,2,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2+\omega))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,2,0)(3,1,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2+\psi_1(0)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(2,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2\times2))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2\times\omega))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2^2))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,2,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_2^{\Omega_2}))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,3,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\psi_2(0)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,0)(3,3,0)(4,4,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\psi_3(0)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega+1))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega+\omega))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,1,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega+\psi_1(0)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,1,0)(4,2,0)(5,3,0)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega+\psi_1(\psi_2(0))))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,1,0)(4,2,1)</math>|| <math>\psi(\Omega_\omega+\psi_1(\Omega_\omega+\psi_1(\Omega_\omega)))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega+\Omega_2)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,3,0)</math>|| <math>\psi(\Omega_\omega+\psi_2(0))</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,3,1)(3,3,0)(4,3,0)</math>|| <math>\psi(\Omega_\omega+\Omega_3)</math>
|-
| <math>(0)(1,1,1)(1,1,0)(2,2,1)(2,2,0)(3,3,1)(3,3,0)(4,4,0)</math>|| <math>\psi(\Omega_\omega+\psi_3(0))</math>
|-
| <math>(0)(1,1,1)(1,1,1)</math>|| <math>\psi(\Omega_\omega\times2)</math>
|-
| <math>(0)(1,1,1)(2,0,0)</math>|| <math>\psi(\Omega_\omega\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega)</math>
|}

==== 4： (0)(1,1,1)(2,1,0)~(0)(1,1,1)(2,1,1) ====
这一部分涉及到[[提升效应]]。

{| class="wikitable"
|-
! BMS !! MOCF
|-
| <math>(0)(1,1,1)(2,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,0,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega+1))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,1,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega+\psi_1(0)))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,1,0)(4,2,1)(5,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega)))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,3,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\psi_2(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,3,1)(4,1,0)(3,3,0)(4,3,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_3)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(1,1,0)(2,2,1)(3,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega+\psi_1(\Omega_\omega\times\Omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(1,1,0)(2,2,1)(3,1,0)(2,2,1)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega+\psi_1(\Omega_\omega\times\Omega+\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(2,0,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega+\psi_1(\Omega_\omega\times\Omega+\Omega_\omega)\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(2,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega+\psi_1(\Omega_\omega\times\Omega+\Omega_\omega+1))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(2,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega+\Omega_2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(2,2,1)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(3,0,0)</math>|| <math>\psi(\Omega_\omega\times\Omega+\Omega_\omega\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(2,2,1)(3,1,0)</math>|| <math>\psi(\Omega_\omega\times\Omega\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega\times\Omega\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,0)</math>|| <math>\psi(\Omega_\omega\times\psi_1(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,1)</math>|| <math>\psi(\Omega_\omega\times\psi_1(\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,1)(5,1,0)</math>|| <math>\psi(\Omega_\omega\times\psi_1(\Omega_\omega\times\Omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,1)(5,1,0)(4,2,1)</math>|| <math>\psi(\Omega_\omega\times\psi_1(\Omega_\omega\times\Omega+\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,1)(5,1,0)(4,2,1)(5,1,0)</math>|| <math>\psi(\Omega_\omega\times\psi_1(\Omega_\omega\times\Omega\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(4,2,1)(5,1,0)(6,2,1)</math>|| <math>\psi(\Omega_\omega\times\psi_1(\Omega_\omega\times\psi_1(\Omega_\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,2,0)</math>|| <math>\psi(\Omega_\omega\times\Omega_2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,2,0)(2,2,0)(3,3,1)(4,2,0)(5,3,0)</math>|| <math>\psi(\Omega_\omega\times\psi_2(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(1,1,0)(2,2,1)(3,2,0)(2,2,0)(3,3,1)(4,3,0)</math>|| <math>\psi(\Omega_\omega\times\Omega_3)</math>
|-
| <math>\color{red}{(0)(1,1,1)(2,1,0)(1,1,1)}</math>|| <math>\color{red}\psi(\Omega_\omega^2)</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(1,1,0)</math>
|<math>\psi(\Omega_\omega^2+1)</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(1,1,0)(2,2,1)</math>
|<math>\psi(\Omega_\omega^2+\psi_1(\Omega_\omega))</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(1,1,0)(2,2,1)(3,1,0)</math>
|<math>\psi(\Omega_\omega^2+\psi_1(\Omega_\omega\times\Omega))</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(1,1,0)(2,2,1)(3,1,0)(2,1,0)(3,2,1)(4,1,0)</math>
|<math>\psi(\Omega_\omega^2+\psi_1(\Omega_\omega\times\Omega+\psi_1(\Omega_\omega\times\Omega)))</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(1,1,0)(2,2,1)(3,1,0)(2,2,0)(3,3,1)(4,1,0)</math>
|<math>\psi(\Omega_\omega^2+\psi_1(\Omega_\omega\times\Omega+\Omega_2))</math>
|-
|<math>(0)(1,1,1)(2,1,0)(1,1,1)(2,1,0)(1,1,1)</math>
|<math>\psi(\Omega_\omega^2\times2)</math>
|-
|<math>(0)(1,1,1)(2,1,0)(2,0,0)</math>
|<math>\psi(\Omega_\omega^2\times\omega)</math>
|-
|<math>(0)(1,1,1)(2,1,0)(2,1,0)</math>
|<math>\psi(\Omega_\omega^2\times\Omega)</math>
|-
|<math>(0)(1,1,1)(2,1,0)(2,1,0)(1,1,0)(2,2,1)</math>
|<math>\psi(\Omega_\omega^2\times\Omega+\psi_1(\Omega_\omega))</math>
|-
|<math>(0)(1,1,1)(2,1,0)(2,1,0)(1,1,0)(2,2,1)(3,1,0)(3,1,0)(2,2,1)</math>
|<math>\psi(\Omega_\omega^2\times\Omega+\Omega_\omega^2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(2,1,0)(1,1,0)(2,2,1)(3,2,0)(3,2,0)</math>|| <math>\psi(\Omega_\omega^2\times\Omega_2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(2,1,0)(1,1,0)(2,2,1)(3,2,0)(3,2,0)(2,2,0)(3,3,1)(4,3,0)(4,3,0)</math>|| <math>\psi(\Omega_\omega^2\times\Omega_3)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(2,1,0)(1,1,1)</math>|| <math>\psi(\Omega_\omega^3)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(2,1,0)(2,1,0)(1,1,1)</math>|| <math>\psi(\Omega_\omega^4)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,0,0)</math>|| <math>\psi(\Omega_\omega^\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,1,0)</math>|| <math>\psi(\Omega_\omega^\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,1,0)(1,1,1)</math>|| <math>\psi(\Omega_\omega^{\Omega_\omega})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,1,0)(4,1,0)(1,1,1)</math>|| <math>\psi(\Omega_\omega^{\Omega_\omega^{\Omega_\omega}})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)</math>|| <math>\psi(\psi_\omega(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(1,1,1)</math>|| <math>\psi(\psi_\omega(0)+\Omega_\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(1,1,1)(2,1,0)(3,2,0)</math>|| <math>\psi(\psi_\omega(0)\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(2,0,0)</math>|| <math>\psi(\psi_\omega(0)\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(2,1,0)</math>|| <math>\psi(\psi_\omega(0)\times\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(2,1,0)(3,2,0)</math>|| <math>\psi(\psi_\omega(0)^2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,0,0)</math>|| <math>\psi(\psi_\omega(0)^\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,1,0)</math>|| <math>\psi(\psi_\omega(0)^\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,1,0)(4,2,0)</math>|| <math>\psi(\psi_\omega(0)^{\psi_\omega(0)})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,1,0)(4,2,0)(4,1,0)(5,2,0)</math>|| <math>\psi(\psi_\omega(0)^{\psi_\omega(0)^{\psi_\omega(0)}})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,2,0)</math>|| <math>\psi(\psi_\omega(1))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(3,2,0)(3,2,0)</math>|| <math>\psi(\psi_\omega(2))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,0,0)</math>|| <math>\psi(\psi_\omega(\omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,1,0)</math> || <math>\psi(\psi_\omega(\Omega))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,1,0)(5,2,0)</math> || <math>\psi(\psi_\omega(\psi_\omega(0)))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)</math> || <math>\psi(\Omega_{\omega+1})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(1,1,1)(2,1,1)(3,2,0)(4,2,0)</math> || <math>\psi(\Omega_{\omega+1}+\psi_\omega(\Omega_{\omega+1}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(3,2,0)(4,2,0)</math> || <math>\psi(\Omega_{\omega+1}\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(4,0,0)</math>|| <math>\psi(\Omega_{\omega+1}\times\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(4,1,0)</math>|| <math>\psi(\Omega_{\omega+1}\times\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(4,2,0)</math>|| <math>\psi(\Omega_{\omega+1}^2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(5,0,0)</math>|| <math>\psi(\Omega_{\omega+1}^\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(5,1,0)</math>|| <math>\psi(\Omega_{\omega+1}^\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,2,0)(5,2,0)</math>|| <math>\psi(\Omega_{\omega+1}^{\Omega_{\omega+1}})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,3,0)</math>|| <math>\psi(\psi_{\omega+1}(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,3,0)(5,3,0)</math>|| <math>\psi(\Omega_{\omega+2})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,0)(4,3,0)(5,4,0)</math>|| <math>\psi(\psi_{\omega+2}(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(1,1,1)</math>|| <math>\psi(\Omega_{\omega\times2}+\Omega_\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(1,1,1)(2,1,0)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_\omega(\Omega_{\omega\times2}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_\omega(\Omega_{\omega\times2}+1))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,1,0)(5,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_\omega(\Omega_{\omega\times2}+\psi_\omega(\Omega_{\omega\times2})))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}+\Omega_{\omega+1})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,3,1)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_{\omega+1}(\Omega_{\omega\times2}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,3,1)(4,3,0)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_{\omega+1}(\Omega_{\omega\times2}+1))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,3,1)(4,3,0)(5,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}+\psi_{\omega+1}(\Omega_{\omega\times2}+\Omega_{\omega+1}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,0)(4,3,1)(4,3,0)(5,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}+\Omega_{\omega+2})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}\times2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,1,0)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,1,0)(1,1,1)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega_\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,1,0)(5,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}\times\psi_\omega(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,1,0)(5,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}\times\psi_\omega(\Omega_{\omega\times2}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega_{\omega+1})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(3,2,0)(4,3,1)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega_{\omega+1}+\psi_{\omega+1}(\Omega_{\omega\times2}))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(3,2,0)(4,3,1)(5,2,0)(4,3,1)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega_{\omega+1}+\Omega_{\omega\times2})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(3,2,0)(4,3,1)(5,3,0)</math>|| <math>\psi(\Omega_{\omega\times2}\times\Omega_{\omega+2})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}^2)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(4,2,0)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}^3)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(5,0,0)</math>|| <math>\psi(\Omega_{\omega\times2}^\omega)</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(5,2,0)</math>|| <math>\psi(\Omega_{\omega\times2}^{\Omega_{\omega+1}})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(5,2,0)(3,2,1)</math>|| <math>\psi(\Omega_{\omega\times2}^{\Omega_{\omega\times2}})</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(5,3,0)</math>|| <math>\psi(\psi_{\omega\times2}(0))</math>
|-
| <math>(0)(1,1,1)(2,1,0)(3,2,1)(4,2,0)(5,3,1)</math>|| <math>\psi(\Omega_{\omega\times3})</math>
|-
| <math>(0)(1,1,1)(2,1,1)</math>|| <math>\psi(\Omega_{\omega^2})</math>
|}

[[分类:分析]]

提升效应

2025-07-14T20:05:45Z

Apocalypse：创建页面，内容为“'''提升效应'''是googology分析时出现的一种现象。 == 定义 == 提升一般不严谨地描述为“在分析时出现的比直觉感知更强的结论”，往往容易伴随分析的错误出现。提升并没有一个严谨的定义，最接近严谨的可能是“在一个极限序数范围内正确的googology分析归纳结论，在超出这个序数范围后，实际结论强于归纳结论”。最经典的提升无疑是Bashicu矩…”

'''提升效应'''是googology分析时出现的一种现象。

== 定义 ==
提升一般不严谨地描述为“在分析时出现的比直觉感知更强的结论”，往往容易伴随分析的错误出现。

提升并没有一个严谨的定义，最接近严谨的可能是“在一个极限序数范围内正确的googology分析归纳结论，在超出这个序数范围后，实际结论强于归纳结论”。

最经典的提升无疑是[[Bashicu矩阵|BMS]]的<math>(0)(1,1,1)(2,1)(1,1,1)</math>
提升，<math>(0)(1,1,1)(1,1,1)\cdots(1,1,1)</math>共<math>n</math>个<math>(1,1,1)</math>是<math>\psi(\Omega_\omega\times{n})</math>，似乎加一个<math>(1,1,1)</math>就让OCF内部加一个<math>\Omega_\omega</math>；但是<math>(0)(1,1,1)(2,1)</math>只有<math>\psi(\Omega_\omega\times\Omega)</math>，而<math>(0)(1,1,1)(2,1)(1,1,1)</math>并不是<math>\psi(\Omega_\omega\times(\Omega+1))</math>，是<math>\psi(\Omega_\omega^2)</math>。

BEAF

2025-07-13T21:05:19Z

Apocalypse：

'''Bowers' Exploding Array Function(BEAF，鲍尔斯爆炸数阵函数)'''是由乔纳森·鲍尔斯(Jonathan Bowers)发明的一种表示大数的记号。

== 定义 ==
BEAF的定义包含以下几部分：'''数阵记号(Array Notation)'''，'''扩展数阵记号(Extended Array Notation)'''，以及尚未严格良定义的'''超指数数阵记号(Tetrational Array Notation)'''及其之后的部分。

=== 数阵记号 ===
一个数阵为如下形式，由若干个项组成：

<math>\{a_1,a_2,\cdots,a_n\}</math>

我们定义以下概念：
# <math>a_1</math>为'''底数'''，记为<math>b</math>。
# <math>a_2</math>为'''指数'''，记为<math>p</math>。
# 指数右侧第一个非1的数称为'''驾驶员'''，驾驶员左侧的第一个项为'''副驾驶'''，左侧的其余项为'''乘客'''。

对于数阵<math>\{a_1,a_2,\cdots,a_n\}</math>，其展开规则如下：

# 如果驾驶员不存在，数阵的值为<math>b^p</math>。
# 如果指数为1，数阵的值为<math>b</math>。
# 如果<math>a_n=1</math>，<math>n>2</math>，数阵的值为<math>\{a_1,a_2,\cdots,a_{n-1}\}</math>。
# 如果以上两条规则都不成立，按照下述规则展开：
## 复制一个这个数阵的副本，并将副本中指数的值减1。
## 将原本数阵的驾驶员减1，全体乘客替换为底数<math>b</math>。
## 将副驾驶换为之前得到的数阵副本。

例如，<math>\{4,8,1,3\}</math>的驾驶员为3，副驾驶为1，于是首先得到副本<math>\{4,7,1,3\}</math>，然后原数阵驾驶员减1，替换乘客得到<math>\{4,4,1,2\}</math>，最后得到最终展开为<math>\{4,4,\{4,7,1,3\},2\}</math>。

=== 扩展数阵记号 ===
一个扩展数阵为如下形式，由若干个项和若干个分隔符<math>(x_i)</math>组成：

<math>\{a_{01},a_{02},\cdots,a_{0m_0}(x_1)a_{11},\cdots,a_{1m_1}(x_2)\cdots(x_3)\cdots(x_n)a_{n1},a_{n2},\cdots,a_{nm_n}\}</math>

我们定义以下概念：
# <math>a_{01}</math>为'''底数'''，记为<math>b</math>。
# <math>a_{02}</math>为'''指数'''，记为<math>p</math>。
# 指数右侧第一个非1的数称为'''驾驶员'''。
# 驾驶员左侧如果不是分隔符，称其左侧的第一个项为'''副驾驶'''。

定义<math>\&</math>符号如下，它生成扩展数阵中的项和分隔符：

<math>1\&^na=a</math>，

<math>b\&a=a,(b-1)\&a</math>，

<math>b\&^{k+1}a=b\&^ka(k)(b-1)\&^{k+1}a</math>。

注：在大部分版本中，<math>\&</math>的指标写在左上侧。此处写在右上侧是为了避免与<math>b^k</math>混淆。

注：有的地方认为形如<math>b\&a</math>的表达式直接表达了一个(扩展)数阵<math>\{a,a,\cdots,a\}</math>，实际上这是错误的。

对于扩展数阵<math>\{a_{01},a_{02},\cdots,a_{0m_0}(x_1)a_{11},\cdots,a_{1m_1}(x_2)\cdots(x_3)\cdots(x_n)a_{n1},a_{n2},\cdots,a_{nm_n}\}</math>，其展开规则如下：

# 如果扩展数阵只有<math>a_{01},a_{02}</math>两项，扩展数阵的值为<math>b^p</math>。
# 如果指数为1，扩展数阵的值为<math>b</math>。
# 如果某个<math>a_{km_k}=1</math>，扩展数阵的值相当于删掉<math>a_{km_k}</math>后得到的扩展数阵的值。
# 如果某个<math>m_k=0</math>，而且<math>k=n</math>或<math>x_k<x_{k+1}</math>，那么扩展数阵的值相当于删掉<math>(x_k)</math>后得到的扩展数阵的值。
# 如果扩展数阵中没有分隔符，按数阵记号的规则展开。
# 如果以上规则均不适用：此时扩展数阵形如<math>\{a,b(x_1)(x_2)(x_3)\cdots(x_n)b_1,b_2,\cdots,b_t\#\}</math>，满足<math>x_1\geq{x_2}\geq\cdots\geq{x_n}</math>，<math>b_1=b_2=\cdots=b_{t-1}=1</math>。
## 如果<math>t=1</math>，其展开为<math>\{b\&^{x_1}a(x_1)b\&^{x_2}a(x_2)b\&^{x_3}a(x_3)\cdots{b}\&^{x_n}a(x_n)b_1-1\#\}</math>。
## 如果<math>t>1</math>，其展开为<math>\{b\&^{x_1}a(x_1)b\&^{x_2}a(x_2)b\&^{x_3}a(x_3)\cdots{b}\&^{x_n}a(x_n)a,a,\cdots,a,\{a,b-1(x_1)(x_2)(x_3)\cdots(x_n)b_1,b_2,\cdots,b_t\#\},b_t-1\#\}</math>。

类似于数阵记号，“乘客”的定义可以如下理解：

分隔符<math>(k)</math>给出了一个尺寸为<math>p^k</math>的“块”(类似于<math>\&</math>符号的结构)，“乘客”则是驾驶员左侧的所有这样的块(不完整的用1补齐)去掉副驾驶员。于是上述展开规则5.和6.可以写为：

# 复制一个这个扩展数阵的副本，并将副本中指数的值减1。
# 将原本扩展数阵的驾驶员减1，全体乘客替换为底数。
# 如果副驾驶存在，将副驾驶换为之前得到的扩展数阵副本。

据此，可以认为扩展数阵记号是数阵记号的扩展。

=== 超指数数阵记号 ===
在扩展数阵记号中，我们用分隔符<math>(k)</math>表示了一个尺寸为<math>p^k</math>的“块”，且其结构也类似于“长度”为<math>p</math>的<math>k</math>维区域。

于是，设想用<math>(0,1)</math>来表示尺寸为<math>p^p</math>的块，使得<math>\{a,b(0,1)2\}=\{a,b(b)2\}</math>。

进一步地，可以设想用<math>(a_1,a_2,\cdots,a_n)</math>来表示尺寸为<math>p^{a_1+a_2p+\cdots+a_np^n}</math>的块，这一系列<math>(a_1,a_2,\cdots,a_n)</math>又有类似于数阵的结构，于是引入<math>((1)1)</math>来表示尺寸为<math>p^{p^p}</math>的块，以此类推，最终可以得到<math>(\cdots(0,1)\cdots)</math>，括号的层数与<math>p</math>有关，来表示尺寸为<math>p\uparrow\uparrow{p}</math>级别的块。

然而，目前尚未有严谨的，描述高阶括号展开规则的定义。不过我们已经知道，它的理想强度达到了[[增长层级#快速增长层级|FGH]]<math>\varepsilon_0</math>的级别。

Goodstein函数

2025-07-13T17:20:44Z

Apocalypse：

古德斯坦函数(Goodstein Function)是由鲁宾•古德斯坦(Reuben Goodstein)构造出的快速增长的函数。

== 定义 ==
首先需要定义数m的以n为底的遗传记法：

假设我们将一个非负整数m表示为n的幂次之和，然后将这些幂指数本身也表示为类似的幂次和，不断重复这一过程，直到所有的最高次指数都小于n。例如，我们可以将100写作<math>2^6+2^5+2^2</math>进一步可以写为<math>2^{2^2+2}+2^{2^2+1}+2^2</math>。这种表示方式称为m的以n为底的遗传记法。

Goodstein定义了一个数列<math>G_k(n)</math>：

对任意自然数n，都有<math>G_0(n)=n</math>

对任意自然数n,k，都有<math>G_{k+1}(n)</math>是把<math>G_k(n)</math>写成以k+2为底的遗传记法，随后把里面所有的k+2改成k+3，最后再把整个数减一所得到的数。

我们拿100作为例子：

<math>G_0(100) = 100 = 2^{2^2+2}+2^{2^2+1}+2^2</math>

<math>G_1(100) = 3^{3^3+3}+3^{3^3+1}+3^3-1 =3^{3^3+3}+3^{3^3+1}+3^2\times2+3\times2+2= 228767924549636</math>

<math>G_2(100) =4^{4^4+4}+4^{4^4+1}+4^2\times2+4\times2+1\approx3.486030062 \times 10^{156}</math>

……

这种快速增长的序列称为 Goodstein 序列。令人惊讶的是，对于 ''n'' 的所有值，<math>G_k(n)</math> 最终达到峰值、下降并返回零。这个事实被称为'''古德斯坦定理'''。更令人惊讶的是，可以证明古德斯坦定理无法用皮亚诺算术来证明。

我们定义古德斯坦函数<math>G(x)</math>等于古德斯坦序列<math>G_k(x)=0</math>时k的值。它的FGH增长率为<math>\varepsilon_0</math>.

== 例子 ==
我们以较小的x作为例子，来计算一下<math>G(x)</math>.为了更加清晰，我们不展示<math>G_k(n)</math> 的具体值，而是展示它的以k+2为底的遗传记法表示。读者可以自行计算取值。
{| class="wikitable mw-collapsible mw-collapsed"
|+x=1
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|1
|-
|1
|0
|}
因此G(1)=1.
{| class="wikitable mw-collapsible mw-collapsed"
|+x=2
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|2
|-
|1
|2
|-
|2
|1
|-
|3
|0
|}
因此G(2)=3.
{| class="wikitable mw-collapsible mw-collapsed"
|+x=3
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|2+1
|-
|1
|3
|-
|2
|3
|-
|3
|2
|-
|4
|1
|-
|5
|0
|}
因此G(3)=5.

从G(4)开始，古德斯坦函数将开始“起飞”
{| class="wikitable mw-collapsible mw-collapsed"
|+x=4
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|<math>2^2</math>
|-
|1
|<math>3^2\times2+3\times2+2</math>
|-
|2
|<math>4^2\times2+4\times2+1</math>
|-
|3
|<math>5^2\times2+5\times2</math>
|-
|4
|<math>6^2\times2+6+5</math>
|-
|9
|<math>11^2\times2+11</math>
|-
|10
|<math>12^2\times2+11</math>
|-
|21
|<math>23^2\times2</math>
|-
|22
|<math>24^2+24\times23+23</math>
|-
|45
|<math>47^2+47\times23</math>
|-
|46
|<math>48^2+48\times22+47</math>
|-
|93
|<math>95^2+95\times22</math>
|-
|189
|<math>191^2+191\times21</math>
|-
|381
|<math>383^2+383\times20</math>
|-
|402653181=<math>3\times2^{27}-3</math>
|<math>402653183^2</math>
|-
|402653182
|<math>402653184\times402653183+402653183</math>
|-
|<math>3\times2^{402653210}-3</math>
|<math>3\times2^{402653210}-1</math>
|-
|<math>3\times2^{402653210}-2</math>
|<math>3\times2^{402653210}-1</math>
|-
|<math>3\times2^{402653211}-3</math>
|0
|}
因此<math>G(4)=3\times2^{402653211}-3</math>

这里它展示了很清晰的“下降”过程。

我们有G(12)大于[[葛立恒数]]这个结论。

== 与 [[增长层级#哈代层级|HH]] 的关系 ==
定义<math>R^\omega_a(n)</math>为将n表示为以a为底的遗传记法，然后将所有的底数a全部替换为<math>\omega</math>所得到的序数。我们可以证明以下结论：

<math>G(n)=H_{R^\omega_2(n)}(3)-3</math>，其中<math>H_\alpha(n)</math>是 [[增长层级#哈代层级|Hardy 层级]]。

=== 证明 ===
以下叙述中总是考虑带乘法的[[康托范式]]和小于<math>\varepsilon_0</math>的序数，希腊字母表示序数，拉丁字母表示正整数。

先证一个引理：'''<math>H_{R^\omega_a(b+1)}(a)=H_{R^\omega_a(b)+1}(a)</math>，<math>a</math>是不小于3的正整数。'''

引理的证明：以下用<math>k</math>表示某个小于<math>a</math>的正整数。我们称一个序数<math>\alpha</math>是好的，如果它的康托范式中出现的所有正整数全都小于<math>a</math>。不难得出，<math>\alpha</math>是好的当且仅当它是某个<math>R^\omega_a(b)</math>的取值。

记<math>R^\omega_a(b+1)=\alpha</math>。将<math>H_\alpha(a)</math>进行多次取基本列，使下标为后继序数，得到<math>H_\beta(a)</math>。那么：

'''1) <math>\beta</math>是好的，不考虑正整数项。'''

由于<math>H_\beta(a)</math>的自变量为<math>a</math>，取基本列时得到的正整数不超过<math>a</math>。那么只要证明产生<math>\beta</math>时得到的<math>a</math>会在下一步被立即使用即可：

若<math>\alpha</math>是后继序数，则<math>\alpha=\beta</math>，显然是好的。

若<math>\alpha</math>是极限序数，设<math>\alpha=\alpha_0+\gamma\times{k}</math>：

# <math>\gamma=\omega</math>，则下一步得到<math>\alpha_0+\gamma\times{(k-1)}+a</math>，已经是后继了，故结论成立；
# <math>\gamma=\omega^{\delta+1}</math>，<math>\delta</math>是大于等于1的序数，则下一步得到<math>\alpha_0+\gamma\times{(k-1)}+\omega^\delta\times{a}</math>，下一步取<math>\omega^\delta\times{a}</math>的基本列，故结论成立；
# <math>\gamma=\omega^{\gamma_0+\omega\times{k}}</math>，则下一步得到<math>\alpha_0+\omega^{\gamma_0+\omega\times{(k-1)}+a}</math>，下一步取<math>\omega^{\cdots+a}</math>的基本列，故结论成立；
# <math>\gamma=\omega^{\gamma_0+\sigma\times{k}}</math>，<math>\sigma</math>是<math>\omega^2</math>的倍数，则此时等效于对<math>\sigma</math>取两次基本列的问题。由于<math>\sigma<\gamma</math>，使用序数的递降法知结论成立。

以上对于<math>\gamma=\omega^\sigma</math>中分别讨论了<math>\sigma=1</math>，<math>\sigma</math>为非1后继序数，<math>\sigma</math>为极限序数但不为<math>\omega^2</math>的倍数，<math>\sigma</math>为<math>\omega^2</math>的倍数的情况。综上，结论1)得证。

易得<math>g_{R^\omega_a(n)}(a)=n</math>，其中g是SGH。设<math>\beta=\theta+1</math>，则<math>\theta</math>是好的。所以，

由于增长层级在取基本列上规则相同，<math>g_\alpha(a)=g_\beta(a)</math>，

<math>g_{\theta+1}(a)=g_\beta(a)=g_\alpha(a)=b+1=g_{R^\omega_a(b)}(a)+1=g_{R^\omega_a(b)+1}(a)</math>，

<math>g_\theta(a)=g_{R^\omega_a(b)}(a)</math>。

由于<math>\theta</math>是好的，遗传记法是唯一的，故<math>\theta=R^\omega_a(b)</math>。从而<math>H_{R^\omega_a(b+1)}(a)=H_\alpha(a)=H_\beta(a)=H_{\theta+1}(a)=H_{R^\omega_a(b)+1}(a)</math>。引理得证。

'''原命题的证明''' 对于一般的自然数<math>k</math>，根据Goodstein序列的定义，有<math>R^\omega_{k+3}(G_{k+1}(n)+1)=R^\omega_{k+2}(G_k(n))</math>。于是，

<math>H_{R^\omega_{k+3}(G_{k+1}(n))}(k+4)=H_{R^\omega_{k+3}(G_{k+1}(n))+1}(k+3)</math>，

使用引理，

<math>=H_{R^\omega_{k+3}(G_{k+1}(n)+1)}(k+3)=H_{R^\omega_{k+2}(G_k(n))}(k+3)</math>。

于是，<math>H_{R^\omega_{k+2}(G_k(n))}(k+3)</math>是与<math>k</math>无关的常数。分别令<math>k=G(n)</math>，<math>k=0</math>，得到

<math>G(n)+3=H_0(G(n)+3)=H_{R^\omega_{G(n)+2}(0)}(G(n)+3)=H_{R^\omega_2(n)}(3)</math>，从而证明了

<math>G(n)=H_{R^\omega_2(n)}(3)-3</math>。

== 枚举 ==

有了刚刚的结论，我们可以快速地求出一些Goodstein函数的值。以下使用[[增长层级#快速增长层级|FGH]]，并且利用了结论<math>H_{\omega^\alpha}(n)=f_{\alpha}(n)</math>：

<math>G(0)=0</math>

<math>G(1)=1</math>

<math>G(2)=3</math>

<math>G(3)=5</math>

<math>G(4)=f_3(3)-3</math>

<math>G(5)=f_5(4)-3</math>

<math>G(6)=f_6(6)-3</math>

<math>G(7)=f_8(8)-3</math>

<math>G(8)=f_{\omega+1}(3)-3</math>

<math>G(9)=f_{\omega+1}(4)-3</math>

<math>G(10)=f_{\omega+1}(6)-3</math>

<math>G(11)=f_{\omega+1}(8)-3</math>

<math>G(12)=f_{\omega+1}(f_3(3))-3</math>

<math>G(13)=f_{\omega+1}(f_4(4))-3</math>

<math>G(14)=f_{\omega+1}(f_6(6))-3</math>

<math>G(15)=f_{\omega+1}(f_8(8))-3</math>

<math>G(16)=f_{\omega^3}(3)-3</math>

<math>G(17)=f_{\omega^4}(4)-3</math>

<math>G(18)=f_{\omega^6}(6)-3</math>

<math>G(19)=f_{\omega^8}(8)-3</math>

<math>G(20)=f_{\omega^\omega}(f_3(3))-3</math>

<math>\cdots</math>

一般地，我们有

<math>G(2\uparrow\uparrow{n})=f_{\omega\uparrow\uparrow(n-1)}(3)-3</math>。

据此可以得到，Goodstein函数的增长率为<math>\varepsilon_0</math>。
[[分类:记号]]

Goodstein函数

2025-07-12T20:39:27Z

Apocalypse：/* 与HH的关系 */

古德斯坦函数(Goodstein Function)是由鲁宾•古德斯坦(Reuben Goodstein)构造出的快速增长的函数。

== 定义 ==
首先需要定义数m的以n为底的遗传记法：

假设我们将一个非负整数m表示为n的幂次之和，然后将这些幂指数本身也表示为类似的幂次和，不断重复这一过程，直到所有的最高次指数都小于n。例如，我们可以将100写作<math>2^6+2^5+2^2</math>进一步可以写为<math>2^{2^2+2}+2^{2^2+1}+2^2</math>。这种表示方式称为m的以n为底的遗传记法。

Goodstein定义了一个数列<math>G_k(n)</math>：

对任意自然数n，都有<math>G_0(n)=n</math>

对任意自然数n,k，都有<math>G_{k+1}(n)</math>是把<math>G_k(n)</math>写成以k+2为底的遗传记法，随后把里面所有的k+2改成k+3，最后再把整个数减一所得到的数。

我们拿100作为例子：

<math>G_0(100) = 100 = 2^{2^2+2}+2^{2^2+1}+2^2</math>

<math>G_1(100) = 3^{3^3+3}+3^{3^3+1}+3^3-1 =3^{3^3+3}+3^{3^3+1}+3^2\times2+3\times2+2= 228767924549636</math>

<math>G_2(100) =4^{4^4+4}+4^{4^4+1}+4^2\times2+4\times2+1\approx3.486030062 \times 10^{156}</math>

……

这种快速增长的序列称为 Goodstein 序列。令人惊讶的是，对于 ''n'' 的所有值，<math>G_k(n)</math> 最终达到峰值、下降并返回零。这个事实被称为'''古德斯坦定理'''。更令人惊讶的是，可以证明古德斯坦定理无法用皮亚诺算术来证明。

我们定义古德斯坦函数<math>G(x)</math>等于古德斯坦序列<math>G_k(x)=0</math>时k的值。它的FGH增长率为<math>\varepsilon_0</math>.

== 例子 ==
我们以较小的x作为例子，来计算一下<math>G(x)</math>.为了更加清晰，我们不展示<math>G_k(n)</math> 的具体值，而是展示它的以k+2为底的遗传记法表示。读者可以自行计算取值。
{| class="wikitable mw-collapsible mw-collapsed"
|+x=1
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|1
|-
|1
|0
|}
因此G(1)=1.
{| class="wikitable mw-collapsible mw-collapsed"
|+x=2
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|2
|-
|1
|2
|-
|2
|1
|-
|3
|0
|}
因此G(2)=3.
{| class="wikitable mw-collapsible mw-collapsed"
|+x=3
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|2+1
|-
|1
|3
|-
|2
|3
|-
|3
|2
|-
|4
|1
|-
|5
|0
|}
因此G(3)=5.

从G(4)开始，古德斯坦函数将开始“起飞”
{| class="wikitable mw-collapsible mw-collapsed"
|+x=4
!k
!<math>G_k(x)</math>以k+2为底的遗传记法表示
|-
|0
|<math>2^2</math>
|-
|1
|<math>3^2\times2+3\times2+2</math>
|-
|2
|<math>4^2\times2+4\times2+1</math>
|-
|3
|<math>5^2\times2+5\times2</math>
|-
|4
|<math>6^2\times2+6+5</math>
|-
|9
|<math>11^2\times2+11</math>
|-
|10
|<math>12^2\times2+11</math>
|-
|21
|<math>23^2\times2</math>
|-
|22
|<math>24^2+24\times23+23</math>
|-
|45
|<math>47^2+47\times23</math>
|-
|46
|<math>48^2+48\times22+47</math>
|-
|93
|<math>95^2+95\times22</math>
|-
|189
|<math>191^2+191\times21</math>
|-
|381
|<math>383^2+383\times20</math>
|-
|402653181=<math>3\times2^{27}-3</math>
|<math>402653183^2</math>
|-
|402653182
|<math>402653184\times402653183+402653183</math>
|-
|<math>3\times2^{402653210}-3</math>
|<math>3\times2^{402653210}-1</math>
|-
|<math>3\times2^{402653210}-2</math>
|<math>3\times2^{402653210}-1</math>
|-
|<math>3\times2^{402653211}-3</math>
|0
|}
因此<math>G(4)=3\times2^{402653211}-3</math>

这里它展示了很清晰的“下降”过程。

我们有G(12)大于[[葛立恒数]]这个结论。

== 与[[HH]]的关系 ==
定义<math>R^\omega_a(n)</math>为将n表示为以a为底的遗传记法，然后将所有的底数a全部替换为<math>\omega</math>所得到的序数。我们可以证明以下结论：

<math>G(n)=H_{R^\omega_2(n)}(3)-3</math>，其中<math>H_\alpha(n)</math>是[[HH|Hardy层级]]。

=== 证明 ===
以下叙述中总是考虑带乘法的[[康托范式]]和小于<math>\varepsilon_0</math>的序数，希腊字母表示序数，拉丁字母表示正整数。

先证一个引理：'''<math>H_{R^\omega_a(b+1)}(a)=H_{R^\omega_a(b)+1}(a)</math>，<math>a</math>是不小于3的正整数。'''

引理的证明：以下用<math>k</math>表示某个小于<math>a</math>的正整数。我们称一个序数<math>\alpha</math>是好的，如果它的康托范式中出现的所有正整数全都小于<math>a</math>。不难得出，<math>\alpha</math>是好的当且仅当它是某个<math>R^\omega_a(b)</math>的取值。

记<math>R^\omega_a(b+1)=\alpha</math>。将<math>H_\alpha(a)</math>进行多次取基本列，使下标为后继序数，得到<math>H_\beta(a)</math>。那么：

'''i) <math>\beta</math>是好的，不考虑正整数项。'''

由于<math>H_\beta(a)</math>的自变量为<math>a</math>，取基本列时得到的正整数不超过<math>a</math>。那么只要证明产生<math>\beta</math>时得到的<math>a</math>会在下一步被立即使用即可：

若<math>\alpha</math>是后继序数，则<math>\alpha=\beta</math>，显然是好的。

若<math>\alpha</math>是极限序数，设<math>\alpha=\alpha_0+\gamma\times{k}</math>：

# <math>\gamma=\omega</math>，则下一步得到<math>\alpha_0+\gamma\times{(k-1)}+a</math>，已经是后继了，故结论成立；
# <math>\gamma=\omega^{\delta+1}</math>，<math>\delta</math>是大于等于1的序数，则下一步得到<math>\alpha_0+\gamma\times{(k-1)}+\omega^\delta\times{a}</math>，下一步取<math>\omega^\delta\times{a}</math>的基本列，故结论成立；
# <math>\gamma=\omega^{\gamma_0+\omega\times{k}}</math>，则下一步得到<math>\alpha_0+\omega^{\gamma_0+\omega\times{(k-1)}+a}</math>，下一步取<math>\omega^{\cdots+a}</math>的基本列，故结论成立；
# <math>\gamma=\omega^{\gamma_0+\sigma\times{k}}</math>，<math>\sigma</math>是<math>\omega^2</math>的倍数，则此时等效于对<math>\sigma</math>取两次基本列的问题。由于<math>\sigma<\gamma</math>，使用序数的递降法知结论成立。

以上对于<math>\gamma=\omega^\sigma</math>中分别讨论了<math>\sigma=1</math>，<math>\sigma</math>为非1后继序数，<math>\sigma</math>为极限序数但不为<math>\omega^2</math>的倍数，<math>\sigma</math>为<math>\omega^2</math>的倍数的情况。综上，结论1)得证。

易得<math>g_{R^\omega_a(n)}(a)=n</math>，其中g是SGH。设<math>\beta=\theta+1</math>，则<math>\theta</math>是好的。所以，

由于增长层级在取基本列上规则相同，<math>g_\alpha(a)=g_\beta(a)</math>，

<math>g_{\theta+1}(a)=g_\beta(a)=g_\alpha(a)=b+1=g_{R^\omega_a(b)}(a)+1=g_{R^\omega_a(b)+1}(a)</math>，

<math>g_\theta(a)=g_{R^\omega_a(b)}(a)</math>。

由于<math>\theta</math>是好的，遗传记法是唯一的，故<math>\theta=R^\omega_a(b)</math>。从而<math>H_{R^\omega_a(b+1)}(a)=H_\alpha(a)=H_\beta(a)=H_{\theta+1}(a)=H_{R^\omega_a(b)+1}(a)</math>。引理得证。

'''原命题的证明''' 对于一般的自然数<math>k</math>，根据Goodstein数列的定义，有<math>R^\omega_{k+3}(G_{k+1}(n)+1)=R^\omega_{k+2}(G_k(n))</math>。于是，

<math>H_{R^\omega_{k+3}(G_{k+1}(n))}(k+4)=H_{R^\omega_{k+3}(G_{k+1}(n))+1}(k+3)</math>，

使用引理，

<math>=H_{R^\omega_{k+3}(G_{k+1}(n)+1)}(k+3)=H_{R^\omega_{k+2}(G_k(n))}(k+3)</math>。

于是，<math>H_{R^\omega_{k+2}(G_k(n))}(k+3)</math>是与<math>k</math>无关的常数。分别令<math>k=G(n)</math>，<math>k=0</math>，得到

<math>G(n)+3=H_0(G(n)+3)=H_{R^\omega_{G(n)+2}(0)}(G(n)+3)=H_{R^\omega_2(n)}(3)</math>，从而证明了

<math>G(n)=H_{R^\omega_2(n)}(3)-3</math>。
[[分类:记号]]

PSS Hydra

2025-07-12T17:20:41Z

Apocalypse：补充与双行BMS的互译

'''PSS Hydra(Pair Sequence System Hydra)'''，是一种Hydra型[[序数记号]]，其行为和[[BO]]之前的[[序数坍缩函数#BOCF|BOCF]]类似。

== 定义 ==

=== 合法表达式 ===
PSS Hydra 的表达式由<math>\psi^H_n(n\in\N)</math><ref>PSS Hydra 的定义中使用的是<math>\psi_n</math>，这里为了和OCF区分，添加了上标H。</ref>，<math>+</math>，<math>0</math>和括号组成。在使用时，<math>\psi^H_n</math>通常简写为<math>pn</math>。

PSS Hydra的合法表达式可以按以下的方式递归定义：

* <math>0</math>为合法表达式，其等级为1；
* 若<math>n</math>为正整数，<math>A</math>为等级<math>\le n+1</math>的合法表达式，则<math>\psi^H_n(A)</math>为合法表达式，其等级为<math>n</math>；
* 若<math>A,B</math>分别为等级为<math>m,n</math>的合法表达式，则<math>A+B</math>也为合法表达式，其等级为<math>\max\{m,n\}</math>。

一个PSS Hydra的合法表达式对应一个小于<math>\omega^{CK}_1</math>的序数，当且仅当其等级为1。

=== 展开 ===

* 若<math>P=0</math>，则其对应序数0；
* 若<math>P=\#+\psi^H_1(0)</math>，则<math>P</math>对应一个后继序数，其前驱为<math>P'=\#</math>；
* 若<math>P=\#_1(\psi^H_k(\#_2+\psi^H_1(0)))</math>，则<math>P[n]=\#_1(\psi^H_k(\#_2)+\psi^H_k(\#_2)+\cdots+\psi^H_k(\#_2))</math>，其中<math>\psi^H_k(\#_2)</math>出现n次；
* 若<math>P=\#_1(\psi^H_k(\#_2(\psi^H_{k+1}(0))))</math>，<math>\#_2</math>不包含<math>\psi^H_k</math>，则<math>P[n]=\#_1(h^n(0))</math>，其中<math>h(x)=\psi^H_k(\#_2(x))</math>。

== 小知识 ==
PSS Hydra名字中的'''“PSS”'''，源于其与'''双行BMS'''的互译。互译规则如下：

对于一个PSS Hydra表达式：
# 从左往右，记录每个<math>\psi^H_{a_i}(i=1,2,\cdots,n)</math>的下标<math>a_i</math>；
# 从左往右，记录每个<math>\psi^H_{a_i}(i=1,2,\cdots,n)</math>的净括号层数(即它左侧的左括号“(”字符个数减去右括号“)”字符个数)<math>b_i</math>；
# 这个PSS Hydra表达式对应的BMS为<math>(b_1,a_1-1)(b_2,a_2-1)\cdots(b_n,a_n-1)</math>。

对于一个双行BMS表达式：
# 取出所有形如<math>(0,k)</math>的列。如果至少取出了2个，在所有这样的列左边添加一个加号，首列除外；
# 将每个<math>(0,k)</math>替换为<math>\psi^H_{k+1}(</math>。接下来往右移动直到遇见第一个加号，在加号左侧添加一个右括号<math>)</math>，如果右边没有加号了，则改为在表达式末尾添加；
# 如果有剩余的双行BMS表达式，将所有第1行的元素减去1，并回到第1步；
# 如果没有剩余的双行BMS表达式，找到所有形如<math>\psi^H_k()</math>的空括号，并补上0。

[[分类:记号]]

线性数阵

2025-07-11T18:53:01Z

Apocalypse：

线性数阵是大部分数阵型记号的基础。

== 定义 ==

=== BEAF ===
这里以[[BEAF]]的线性数阵为例。

一个合法的 BEAF 线性数阵表达式形如<math>\{b,p,a_1,a_2,\cdots,a_n\}</math>其中<math>n</math>为非负整数，<math>b,p,a_i</math>均为正整数。

我们进行以下约定：

# 数阵的第一个数<math>b</math>称为'''底数'''；
# 数阵的第二个数<math>p</math>称为'''指数'''；
# 指数后面第一个大于1的数称为'''驾驶员'''，例如<math>\{3,2,{\color{blue}1},{\color{red}2},4\}</math>中的2，<math>\{4,{\color{blue}4},{\color{red}4},4\}</math>中红色的4；
# 驾驶员左边相邻的数称为'''副驾驶'''，例如上一条中蓝色的数。

BEAF 线性数阵的展开规则如下：

# 若没有驾驶员，则数阵的值为<math>b^p</math>；
# 若指数为1，则数阵的值为<math>b</math>；
# 否则，将驾驶员-1，副驾驶改为"整个数阵指数-1后的值"，将副驾驶左边的数全部替换为底数。例如，<math>\{4,3,{\color{blue}1},{\color{red}2}\}
=\{4,4,{\color{blue}\{4,2,1,2\}},{\color{red}1}\}
=\{4,4,\{4,4,{\color{blue}\{4,1,1,2\}},{\color{red}1}\},1\}
=\{4,4,\{4,4,4,1\},1\}</math>。

=== 改进 ===
这里介绍一种改进的线性数阵。它将经典的线性数阵改成了容易分析增长率的一元函数，将每一项的默认值改成了0，且删除了对增长率提升没有帮助的操作。

一个合法的线性数阵表达式形如<math>F(x,a_1,a_2,\cdots,a_n)</math>，其中，<math>x,n,a_i</math>均为非负整数。

我们用"#"表示任意序列，"Z"表示由若干个0组成的序列。

该线性数阵的展开规则如下：

# (基础规则)只有一项时，有<math>F(x)=x+1</math>；
# (后继规则)若第二项不为0，有<math>F(x,a+1,\#)=f^x(x)</math>，其中<math>f(x)=F(x,a,\#)</math>。例如：<math>F(3,1,4)=F(F(F(3,0,4),0,4),0,4)</math>；
# (删尾规则)若末项为0，有<math>F(\#,0)=F(\#)</math>，例如：<math>F(2,1,0)=F(2,1)</math>。
# (借位规则)否则，第二项为0且存在不为0的项。此时有<math>F(x,Z,0,a+1,\#)=F(x,Z,x,a,\#)</math>。例如：<math>F(2,0,2,5)=F(2,2,1,5)</math>。

== 增长率分析 ==
下面用[[增长层级#快速增长层级|快速增长层级]]对改进的线性数阵进行增长率分析：

<math>F(x)=F(x,0)=x+1=f_0(x)</math>

<math>F(x,1)=F^x(x)\sim f_0^x(x)=f_1(x)</math>

<math>F(x,2)\sim f_1^x(x)=f_2(x)</math>

<math>F(x,n)\sim f_n(x)</math>

<math>F(x,0,1)=F(x,x)\sim f_x(x)=f_\omega(x)</math>

<math>F(x,1,1)=F(F(\cdots,0,1),0,1)\sim f_{\omega+1}(x)</math>

<math>F(x,n,1)\sim f_{\omega+n}(x)</math>

<math>F(x,0,2)=F(x,x,1)\sim f_{\omega+x}(x)=f_{\omega\cdot 2}(x)</math>

<math>F(x,0,n)\sim f_{\omega\cdot n}(x)</math>

<math>F(x,0,0,1)=F(x,0,x)\sim f_{\omega x}(x)=f_{\omega^2}(x)</math>

<math>F(x,1,0,1)\sim f_{\omega^2+1}(x)</math>

<math>F(x,0,1,1)=F(x,x,0,1)\sim f_{\omega^2+x}(x)=f_{\omega^2+\omega}(x)</math>

<math>F(x,0,0,2)=F(x,0,x,1)\sim f_{\omega^2+\omega x}(x)=f_{\omega^22}(x)</math>

<math>F(x,0,0,0,1)=F(x,0,0,x)\sim f_{\omega^2x}(x)=f_{\omega^3}(x)</math>

<math>F(x,0,0,0,0,1)\sim f_{\omega^4}(x)</math>

<math>F(x,\underbrace{0,\cdots,0}_n,1)\sim f_{\omega^n}(x)</math>

一般来说，单独的线性数阵的极限增长率为<math>\omega^\omega</math>，但其强度会随"后继规则"的变化而变化。

例如，若把第二条规则改为<math>F(x,a+1,\#)=F(x+1,a,\#)</math>，则上述分析应该在[[增长层级#哈代层级|哈代层级]]下进行，故极限函数的增长率相当于<math>H_{\omega^\omega}(x)\sim f_\omega(x)</math>。

== 小知识 ==
对于上文[[线性数阵#增长率分析|增长率分析]]中的记号，通过如下方法可以快速得到增长率：
# 取出一个表达式<math>F(x,a_0,a_1,\cdots,a_n)</math>；
# 取出<math>a_0,a_1,\cdots,a_n</math>的部分并反转，得到<math>a_n,\cdots,a_1,a_0</math>；
# <math>F(x,a_0,a_1,\cdots,a_n)</math>的增长率即为<math>\omega^n\times{a_n}+\cdots+\omega^1\times{a_1}+\omega^0\times{a_0}</math>。
举个例子：<math>F(x,{\color{red}0},{\color{green}1},{\color{blue}1})</math>的增长率即为<math>\omega^2\times{\color{blue}1}+\omega^1\times{\color{green}1}+\omega^0\times{\color{red}0}</math>。

由于以上原因，(单行)线性数阵也被称为'''<math>\omega</math>进制数阵'''，因为<math>\omega^n\times{a_n}+\cdots+\omega^1\times{a_1}+\omega^0\times{a_0}</math>类似于一个“<math>\omega</math>进制数”。

另外，表达式<math>\omega^n\times{a_n}+\cdots+\omega^1\times{a_1}+\omega^0\times{a_0}</math>对于每个<math>a_i(i=0,1,\cdots,n)</math>都是“线性”的，这也是线性数阵中“线性”一词的来源。
[[分类:记号]]

BMS分析

2025-07-08T19:30:25Z

Apocalypse：

BMS分析

2025-07-08T17:57:08Z

Apocalypse：

BMS分析

2025-07-08T17:10:01Z

Apocalypse：

BMS分析

2025-07-08T16:14:26Z

Apocalypse：/* 2：双行BMS */

燃烧数

2025-07-04T19:00:21Z

Apocalypse：创建页面，内容为“'''燃烧数(Fusible number)'''，是一系列序型为<math>\varepsilon_0</math>的正有理数。 === 定义 === 考虑以下的数学问题：一个人处于一个封闭的房间之中。他想要测量一段时间，但是房间之中没有钟表，只有一系列恰好能够在一小时内燃尽的绳索。这些绳索的燃烧速度是不均匀的，因此不能通过其长度来判断时间，但是可以通过将其两端全部点燃的方式测量一…”

'''燃烧数(Fusible number)'''，是一系列序型为<math>\varepsilon_0</math>的正有理数。

=== 定义 ===
考虑以下的数学问题：一个人处于一个封闭的房间之中。他想要测量一段时间，但是房间之中没有钟表，只有一系列恰好能够在一小时内燃尽的绳索。这些绳索的燃烧速度是不均匀的，因此不能通过其长度来判断时间，但是可以通过将其两端全部点燃的方式测量一半的时间。现在想问：仅靠这些绳索，这个人可以在房间之中测量哪些时间？

这里所有能够测量出来的时间称为'''燃烧数'''。

可以证明：
如果<math>a</math>和<math>b</math>均为燃烧数，那么<math>(a+b+1)/2</math>也是燃烧数，并且由这个规则可以从<math>0</math>生成所有的燃烧数。

（等待更新）

慢速增长层级

2025-06-28T18:59:06Z

Apocalypse：

'''慢速增长层级(Slow-Growing Hierarchy,SGH)'''是一种[[增长层级]]。

==== 定义 ====
<math>g_0(n)=0</math>

<math>g_{\alpha+1}(n) =g_{\alpha}(n)+1</math>

<math>g_\alpha(n)=g_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>

慢速增长层级

2025-06-28T18:58:07Z

Apocalypse：创建页面，内容为“'''缓慢增长层级(Slow-Growing Hierarchy,SGH)'''是一种增长层级。 ==== 定义 ==== <math>g_0(n)=0</math> <math>g_{\alpha+1}(n) =g_{\alpha}(n)+1</math> <math>g_\alpha(n)=g_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>”

'''缓慢增长层级(Slow-Growing Hierarchy,SGH)'''是一种[[增长层级]]。

==== 定义 ====
<math>g_0(n)=0</math>

<math>g_{\alpha+1}(n) =g_{\alpha}(n)+1</math>

<math>g_\alpha(n)=g_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>

中速增长层级

2025-06-28T18:55:27Z

Apocalypse：创建页面，内容为“'''中速增长层级(Middle-Growing Hierarchy,MGH)'''是一种增长层级。 ==== 定义 ==== <math>m_0(n)=n+1</math> <math>m_{\alpha+1}(n) =m_{\alpha}(m_{\alpha}(n))</math> <math>m_\alpha(n)=m_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>”

'''中速增长层级(Middle-Growing Hierarchy,MGH)'''是一种[[增长层级]]。

==== 定义 ====
<math>m_0(n)=n+1</math>

<math>m_{\alpha+1}(n) =m_{\alpha}(m_{\alpha}(n))</math>

<math>m_\alpha(n)=m_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>

快速增长层级

2025-06-28T18:31:16Z

Apocalypse：/* 定义 */

'''快速增长层级(Fast-Growing Hierarchy,FGH)'''是一种[[增长层级]]。

==== 定义 ====
<math>f_0(n)=n+1</math>

<math>f_{\alpha+1}(n) = \underbrace{f_{\alpha}(f_{\alpha}(f_{\alpha}(\cdots f_{\alpha}(n))))}_{n \text{ times}}</math>

<math>f_\alpha(n)=f_{\alpha[n]}(n),{\rm if}\ \alpha{\rm \ is \ a \ limit\ ordinal}</math>