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

BMS:修订间差异

来自Googology Wiki
Z留言 | 贡献
无编辑摘要
Tabelog留言 | 贡献
Tabelog移动页面Bashicu矩阵BMS
 
(未显示3个用户的7个中间版本)
第1行: 第1行:
Bashicu矩阵系统(Bashicu Matrix System,'''BMS''')是一个[[序数记号]]。Bashicu Hyudora在2018年给出了它的良好定义。直至今日,BMS依然是已经证明[[良序]]的最强的序数记号。
Bashicu 矩阵系统(Bashicu Matrix System,'''BMS''')是一个[[序数记号]]。Bashicu Hyudora 在 2018 年给出了它的定义。直至今日,BMS 依然是已经证明[[良序]]的最强的序数记号。


== 定义 ==
== 定义 ==


=== 原定义 ===
=== 原定义 ===
Bashicu最初在他的未命名的BASIC编程语言改版上提交了BMS的定义<ref> [https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:BashicuHyudora/BASIC%E8%A8%80%E8%AA%9E%E3%81%AB%E3%82%88%E3%82%8B%E5%B7%A8%E5%A4%A7%E6%95%B0%E3%81%AE%E3%81%BE%E3%81%A8%E3%82%81#.E3.83.90.E3.82.B7.E3.82.AF.E8.A1.8C.E5.88.97.E6.95.B0.28Bashicu_matrix_number.29 The summarization of the large numbers in BASIC language (Japanese article)]</ref>。BMS的原定义是一个大数记号,理论的输出是一个大数。该程序并未设计为实际运行,原因在于语言修改的未定义性,同时也受限于内存与计算时间的现实约束,无法计算出这个大数的实际最终值。因此,Fish编写了名为"Bashicu矩阵计算器"的程序来演示预期的计算流程(该程序已得到Bashicu验证)。故Bashicu矩阵的正式定义可参考Fish程序的源代码<ref>https://github.com/kyodaisuu/basmat/blob/master/basmat.c</ref>
Bashicu 最初在他的未命名的 BASIC 编程语言改版上提交了 BMS 的定义。<ref name=":0"> Bashicu Hyudora (2015). [https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:BashicuHyudora/BASIC%E8%A8%80%E8%AA%9E%E3%81%AB%E3%82%88%E3%82%8B%E5%B7%A8%E5%A4%A7%E6%95%B0%E3%81%AE%E3%81%BE%E3%81%A8%E3%82%81#.E3.83.90.E3.82.B7.E3.82.AF.E8.A1.8C.E5.88.97.E6.95.B0.28Bashicu_matrix_number.29 Summary of large numbers in BASIC language] (BASIC言語による巨大数のまとめ). ''Googology Wiki''.</ref>BMS 的原定义是一个大数记号,理论的输出是一个大数。该程序并未设计为实际运行,原因在于语言修改的未定义性,同时也受限于内存与计算时间的现实约束,无法计算出这个大数的实际最终值。因此,Fish 编写了名为"Bashicu 矩阵计算器"的程序来演示预期的计算流程(该程序已得到 Bashicu 验证)。故 Bashicu 矩阵的正式定义可参考 Fish 程序的源代码。<ref>Kyodaisuu (2020). [https://github.com/kyodaisuu/basmat/blob/master/basmat.c basmat]. ''Gthub''.</ref>


=== 正式定义 ===
=== 正式定义 ===
中文googology社区提到BMS默认是一个序数记号。以下是序数记号BMS的定义及说明:
中文 googology 社区提到 BMS 默认是一个序数记号。以下是序数记号 BMS 的定义及说明:


首先是BMS合法式:BMS的合法式是二维的自然数构成的序列,在外观上看是一个矩阵。如<math>\begin{pmatrix} 0 & 1&2&1 \\ 0&1&1&1\\0&1&0&1 \end{pmatrix}</math>就是一个BMS的合法式。在很多场合,这种二维的结构书写起来不是很方便,因此我们也常常把BMS从左到右、从上到下按列书写,每一列的不同行之间用逗号隔开,不同列之间用括号隔开。例如,上面的BMS也可以写成<math>(0,0,0)(1,1,1)(2,1,0)(1,1,1)</math>.在很多情况下,除首列外,列末的0也可以省略不写,例如上面的BMS写为<math>(0)(1,1,1)(2,1)(1,1,1)</math>.
首先是 BMS 合法式:BMS 的合法式是二维的自然数构成的序列,在外观上看是一个矩阵。如 <math>\begin{pmatrix} 0 & 1&2&1 \\ 0&1&1&1\\0&1&0&1 \end{pmatrix}</math> 就是一个 BMS 的合法式。在很多场合,这种二维的结构书写起来不是很方便,因此我们也常常把BMS从左到右、从上到下按列书写,每一列的不同行之间用逗号隔开,不同列之间用括号隔开。例如,上面的 BMS 也可以写成 <math>(0,0,0)(1,1,1)(2,1,0)(1,1,1)</math>。在很多情况下,除首列外,列末的 0 也可以省略不写,例如上面的 BMS 写为 <math>(0)(1,1,1)(2,1)(1,1,1)</math>


理论上来说,只要是这样的式子就可以按照BMS的规则进行处理了。但实际操作过程中,我们还可以排除一些明显不标准的式子:
理论上来说,只要是这样的式子就可以按照 BMS 的规则进行处理了。但实际操作过程中,我们还可以排除一些明显不标准的式子:


* 首列并非全0
* 首列并非全 0
* 每一列并非不严格递减,即出现一列中下面的数大于上面的数。
* 每一列并非不严格递减,即出现一列中下面的数大于上面的数
* 出现一个元素a,它比它同行左边所有元素都大超过1.
* 出现一个元素 a,它比它同行左边所有元素都大超过 1


在了解BMS的展开规则之前,需要先了解一些概念。
在了解 BMS 的展开规则之前,需要先了解一些概念。


# 第一行元素的'''父项''':对于位于第一行的元素a,它的父项b是满足以下条件的项当中,位于最右边的项:1)同样位于第一行且在a的左边;2) 小于a。这里和[[初等序列系统|PrSS]]判定父项的规则是相同的。显然,0没有父项。
# 第一行元素的'''父项''':对于位于第一行的元素 a,它的父项 b 是满足以下条件的项当中,位于最右边的项:1. 同样位于第一行且在 a 的左边;2. 小于 a。这里和 [[初等序列系统|PrSS]] 判定父项的规则是相同的。显然,0 没有父项。
# '''祖先项''':一个元素自己,以及它的父项、父项的父项、父项的父项的父项……共同构成它的祖先项。
# '''祖先项''':一个元素自己,以及它的父项、父项的父项、父项的父项的父项……共同构成它的祖先项。
# 其余行元素的父项:对于不位于第一行的元素c,它的父项d指满足以下条件的项当中,位于最右边的项: 1)与c位于同一行且在c的左边; 2)小于c;3)d正上方的项e是c正上方的项f的祖先项。0没有父项。
# 其余行元素的父项:对于不位于第一行的元素 c,它的父项 d 指满足以下条件的项当中,位于最右边的项:1. 与c位于同一行且在 c 的左边;2. 小于 c;3. d 正上方的项 e 是 c 正上方的项f的祖先项。0 没有父项。
# '''坏根''':最后一列位于最下方的非零元素的父项所在列,称为坏根。如果最后一列所有元素为0,则这个BMS表达式无坏根。值得一提的是,末列最靠下的非零元素记作'''LNZ'''(Lowermost Non-Zero)
# '''坏根''':最后一列位于最下方的非零元素的父项所在列,称为坏根。如果最后一列所有元素为 0,则这个 BMS 表达式无坏根。值得一提的是,末列最靠下的非零元素记作 '''LNZ'''(Lowermost Non-Zero)
# '''好部'''、'''坏部''':这两个概念与PrSS是相似的。位于坏根左边的所有列称为好部,记作G,G可以为空;从坏根到倒数第二列(包括坏根、倒数第二列)的部分称为坏部,记作B。
# '''好部'''、'''坏部''':这两个概念与 PrSS 是相似的。位于坏根左边的所有列称为好部,记作 G,G 可以为空;从坏根到倒数第二列(包括坏根、倒数第二列)的部分称为坏部,记作B。
# '''阶差向量''':在一个n行BMS中,我们把末列记为<math>(\alpha_1,\alpha_2,\cdots,\alpha_n)</math>,把坏根列记为<math>(\beta_1,\beta_2,\cdots,\beta_n)</math>,并且我们规定<math>\alpha_{n+1}=0</math>.则阶差向量<math>\Delta=(\delta_1,\delta_2,\cdots,\delta_n)</math>按照这样的规则得到:<math>\delta_i = \begin{cases} \alpha_i-\beta_i, & \alpha_{i+1}\neq0 \\ 0, & \alpha_{i+1}=0 \end{cases}</math>。通俗的说,如果末列的第<math>i+1</math>项等于0,则<math>\delta_i=0</math>,否则<math>\delta_i</math>等于末列第i行减去坏根列第i行。阶差向量记作<math>\Delta</math>.
# '''阶差向量''':在一个 n 行 BMS 中,我们把末列记为 <math>(\alpha_1,\alpha_2,\cdots,\alpha_n)</math>,把坏根列记为 <math>(\beta_1,\beta_2,\cdots,\beta_n)</math>,并且我们规定 <math>\alpha_{n+1}=0</math>。则阶差向量<math>\Delta=(\delta_1,\delta_2,\cdots,\delta_n)</math>按照这样的规则得到:<math>\delta_i = \begin{cases} \alpha_i-\beta_i, & \alpha_{i+1}\neq0 \\ 0, & \alpha_{i+1}=0 \end{cases}</math>。通俗的说,如果末列的第 <math>i+1</math> 项等于0,则 <math>\delta_i=0</math>,否则 <math>\delta_i</math> 等于末列第 i 行减去坏根列第 i 行。阶差向量记作 <math>\Delta</math>
# <math>B_m</math>:<math>B_m</math>是B中每一列都加上<math>\Delta</math>的m倍所得到的新矩阵。但是有一点需要注意:如果B中某个元素t的祖先项不包含坏根中的元素,则在<math>B_m</math>对应位置的元素的值依然是t,它不加<math>\Delta</math>.
# <math>B_m</math><math>B_m</math>是 B 中每一列都加上 <math>\Delta</math> 的 m 倍所得到的新矩阵。但是有一点需要注意:如果 B 中某个元素 t 的祖先项不包含坏根中的元素,则在 <math>B_m</math> 对应位置的元素的值依然是 t,它不加 <math>\Delta</math>


了解概念后,以下是BMS的展开规则:
了解概念后,以下是 BMS 的展开规则:


# 空矩阵=0
# 空矩阵 = 0
# 如果表达式是非空矩阵S,如果它没有坏根,那么S等于S去掉最后一列之后,剩余部分的后继
# 如果表达式是非空矩阵 S,如果它没有坏根,那么 S 等于 S 去掉最后一列之后,剩余部分的后继
# 否则,确定这个BMS表达式S的坏根、G、B、<math>\Delta</math>,S的基本列第n项<math>S[n]=G\sim B\sim B_1 \sim B_2\sim B_3\sim\cdots\sim B_{n-1}</math>.其中~表示序列拼接。或者称S的展开式是<math>G\sim B \underbrace{\sim B_1\sim B_2\sim \cdots}_{\omega}</math>.
# 否则,确定这个 BMS 表达式 S 的坏根、G、B、<math>\Delta</math>,S 的基本列第 n 项<math>S[n]=G\sim B\sim B_1 \sim B_2\sim B_3\sim\cdots\sim B_{n-1}</math>。其中 ~ 表示序列拼接。或者称 S 的展开式是 <math>G\sim B \underbrace{\sim B_1\sim B_2\sim \cdots}_{\omega}</math>


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


以下是BMS展开的一些实例:
以下是 BMS 展开的一些实例:


例一:<math>(0,0,0)(1,1,1)(2,2,1)(3,2,0)(0,0,0)</math>
例一:<math>(0,0,0)(1,1,1)(2,2,1)(3,2,0)(0,0,0)</math>


因为末列全都是0,因此这个BMS没有坏根。根据规则2,它是<math>(0,0,0)(1,1,1)(2,2,1)(3,2,0)</math>的后继。
因为末列全都是 0,因此这个 BMS 没有坏根。根据规则 2,它是 <math>(0,0,0)(1,1,1)(2,2,1)(3,2,0)</math> 的后继。


例二:<math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,2,0)</math>
例二:<math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,2,0)</math>


LNZ是末列第二行的2.首先确定末列第1行元素的祖先项,即标红的部分(末列本身不染色,下同):<math>({\color{red}0},0,0)({\color{red}1},1,1)({\color{red}2},2,2)({\color{red}3},3,3)(4,2,0)</math>.因此末列第二行的2的父项只能在含有标红元素的这些列中选取。于是确定LNZ的父项为(标绿):<math>({\color{red}0},0,0)({\color{red}1},{\color{green}1},1)({\color{red}2},2,2)({\color{red}3},3,3)(4,2,0)</math>.因此确定<math>(1,1,1)</math>是坏根。好部G是<math>(0,0,0)</math>,坏部B是<math>(1,1,1)(2,2,2)(3,3,3)</math>.计算出阶差向量<math>\Delta=(3,0,0)</math>.检查B中是否存在祖先项不包含坏根中元素的项(当然,我们只需要检查<math>\Delta</math>非零的那些行),很幸运,没有。于是我们得到展开式是<math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,1,1)(5,2,2)(6,3,3)(7,1,1)(8,2,2)(9,3,3)\cdots</math>
LNZ 是末列第二行的 2。首先确定末列第 1 行元素的祖先项,即标红的部分(末列本身不染色,下同):<math>({\color{red}0},0,0)({\color{red}1},1,1)({\color{red}2},2,2)({\color{red}3},3,3)(4,2,0)</math>。因此末列第二行的 2 的父项只能在含有标红元素的这些列中选取。于是确定 LNZ 的父项为(标绿):<math>({\color{red}0},0,0)({\color{red}1},{\color{green}1},1)({\color{red}2},2,2)({\color{red}3},3,3)(4,2,0)</math>。因此确定 <math>(1,1,1)</math> 是坏根。好部 G 是 <math>(0,0,0)</math>,坏部 B 是 <math>(1,1,1)(2,2,2)(3,3,3)</math>。计算出阶差向量 <math>\Delta=(3,0,0)</math>。检查 B 中是否存在祖先项不包含坏根中元素的项(当然,我们只需要检查 <math>\Delta</math> 非零的那些行),很幸运,没有。于是我们得到展开式是 <math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,1,1)(5,2,2)(6,3,3)(7,1,1)(8,2,2)(9,3,3)\cdots</math>


例三:<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)</math>
例三:<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)</math>


LNZ是末列第四行的1.首先确定末列第一行元素7的祖先项(标红):<math>({\color{red}0},0,0,0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},1,1,1)({\color{red}6},2,2,1)(7,3,1,1)</math>.在含有标红元素的列中寻找末列第二行元素3的祖先项(标绿):<math>({\color{red}0},{\color{green}0},0,0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},{\color{green}1},1,1)({\color{red}6},{\color{green}2},2,1)(7,3,1,1)</math>.在含有标绿元素的列中寻找末列第三行元素1的祖先项(标蓝):<math>({\color{red}0},{\color{green}0},{\color{dodgerblue}0},0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},{\color{green}1},1,1)({\color{red}6},{\color{green}2},2,1)(7,3,1,1)</math>.在含有标蓝元素的列中寻找LNZ的父项,即首列第四行的0.于是得到坏根是<math>(0,0,0,0)</math>,好部G是空矩阵,坏部B是<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)</math>,计算阶差向量<math>\Delta=(7,3,1,0)</math>。检查B中是否存在祖先项不包含坏根中元素的项(只检查<math>\Delta</math>非0的行)得到第五列第三行的0祖先项不经过坏根。于是我们得到展开式是<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,{\color{red}0},0)(5,1,1,1)(6,2,2,1)(7,3,1,0)(8,4,2,1)(9,5,3,1)(10,6,2,1)(11,5,{\color{red}0},0)(12,4,2,1)(13,5,3,1)(14,6,2,0)(15,7,3,1)(16,8,4,1)(17,9,3,1)(18,8,{\color{red}0},0)(19,7,3,1)(20,8,4,1)\cdots</math>
LNZ 是末列第四行的 1。首先确定末列第一行元素 7 的祖先项(标红):<math>({\color{red}0},0,0,0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},1,1,1)({\color{red}6},2,2,1)(7,3,1,1)</math>。在含有标红元素的列中寻找末列第二行元素 3 的祖先项(标绿):<math>({\color{red}0},{\color{green}0},0,0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},{\color{green}1},1,1)({\color{red}6},{\color{green}2},2,1)(7,3,1,1)</math>。在含有标绿元素的列中寻找末列第三行元素 1 的祖先项(标蓝):<math>({\color{red}0},{\color{green}0},{\color{dodgerblue}0},0)({\color{red}1},1,1,1)({\color{red}2},2,2,1)({\color{red}3},3,1,1)({\color{red}4},2,0,0)({\color{red}5},{\color{green}1},1,1)({\color{red}6},{\color{green}2},2,1)(7,3,1,1)</math>。在含有标蓝元素的列中寻找 LNZ 的父项,即首列第四行的 0。于是得到坏根是 <math>(0,0,0,0)</math>,好部 G 是空矩阵,坏部 B 是 <math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)</math>,计算阶差向量 <math>\Delta=(7,3,1,0)</math>。检查 B 中是否存在祖先项不包含坏根中元素的项(只检查 <math>\Delta</math> 0 的行)得到第五列第三行的 0 祖先项不经过坏根。于是我们得到展开式是


展开BMS可以靠BMS计算器<ref>http://gyafun.jp/ln/basmat.cgi</ref>或notation explorer<ref>https://hypcos.github.io/notation-explorer/</ref>辅助。
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,{\color{red}0},0)(5,1,1,1)(6,2,2,1)(7,3,1,0)(8,4,2,1)(9,5,3,1)(10,6,2,1)(11,5,{\color{red}0},0)(12,4,2,1)(13,5,3,1)(14,6,2,0)(15,7,3,1)(16,8,4,1)(17,9,3,1)(18,8,{\color{red}0},0)(19,7,3,1)(20,8,4,1)\cdots</math>
 
展开 BMS 可以靠 [https://gyafun.jp/ln/basmat.cgi Bashicu Matrix Calculator] 或 [https://hypcos.github.io/notation-explorer/ Notation Explorer] 辅助。


=== 数学定义 ===
=== 数学定义 ===
kotetian给出BMS的数学定义。但是他给出的定义是大数记号版本的。以下是根据他的定义改写的序数记号版BMS的定义:
kotetian 给出 BMS 的数学定义,但是他给出的定义是大数记号版本的。以下是根据他的定义改写的序数记号版 BMS 的定义:


<math>\mathrm{Matrix:}{\boldsymbol S}={\boldsymbol S}_0{\boldsymbol S}_1\cdots{\boldsymbol S}_{X-1}</math>
<math>\mathrm{Matrix:}{\boldsymbol S}={\boldsymbol S}_0{\boldsymbol S}_1\cdots{\boldsymbol S}_{X-1}</math>
第81行: 第83行:


== 历史 ==
== 历史 ==
Bashicu在2015年的时候给出了第一版BMS的定义,即BM1。BM1创建后的首个问题便是其是否必然终止。这一疑问直到2016年用户KurohaKafka在日本论坛2ch.net发表终止性证明<ref>http://wc2014.2ch.net/test/read.cgi/math/1448211924/152-155n</ref>才暂告段落。然而Hyp cos通过构造非终止序列推翻了该证明<ref>https://googology.fandom.com/wiki/Talk:Bashicu_matrix_system?oldid=118833#Something_wrong_happens</ref>
Bashicu 在2015年的时候给出了第一版 BMS 的定义,即 BM1。BM1 创建后的首个问题便是其是否必然终止。这一疑问直到 2016 年用户 KurohaKafka 在日本论坛 2ch.net 发表终止性证明才暂告段落。<ref>http://wc2014.2ch.net/test/read.cgi/math/1448211924/152-155n</ref>然而 Hyp cos 通过构造非终止序列推翻了该证明。<ref>Hyp cos (2016). [https://googology.fandom.com/wiki/Talk:Bashicu_matrix_system?oldid=118833#Something_wrong_happens Talk: Bashicu Matrix System, Something wrong happens]. ''Googology Wiki''.</ref>


为此,Bashicu发布第二版(BM2),以BASIC语言重新实现算法<ref>https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:BashicuHyudora/BASIC%E8%A8%80%E8%AA%9E%E3%81%AB%E3%82%88%E3%82%8B%E5%B7%A8%E5%A4%A7%E6%95%B0%E3%81%AE%E3%81%BE%E3%81%A8%E3%82%81#.E3.83.90.E3.82.B7.E3.82.AF.E8.A1.8C.E5.88.97.E6.95.B0.28Bashicu_matrix_number.29</ref>。2018年6月12日,他再次更新定义至BM3<ref>https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:Kyodaisuu/%E3%83%90%E3%82%B7%E3%82%AF%E8%A1%8C%E5%88%97%E6%9C%80%E6%96%B0%E3%83%90%E3%83%BC%E3%82%B8%E3%83%A7%E3%83%B3</ref>,但当月内Alemagno12便发现存在不终止的例证<ref>https://googology.fandom.com/wiki/User_blog:Alemagno12/BM3_has_an_infinite_loop</ref>
为此,Bashicu 发布第二版(BM2),以 BASIC 语言重新实现算法。<ref name=":0" />2018年6月12日,他再次更新定义至 BM3,<ref>Kyodaisuu (2018). [https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:Kyodaisuu/%E3%83%90%E3%82%B7%E3%82%AF%E8%A1%8C%E5%88%97%E6%9C%80%E6%96%B0%E3%83%90%E3%83%BC%E3%82%B8%E3%83%A7%E3%83%B3 Bashiku Matrix Version 3] (バシク行列バージョン3). ''Googology Wiki''.</ref>但当月内 Alemagno12 便发现存在不终止的例证。<ref>Alemagno12 (2018). [https://googology.fandom.com/wiki/User_blog:Alemagno12/BM3_has_an_infinite_loop BM3 has an infinite loop]. ''Googology Wiki''.</ref>


2018年11月11日,P進大好きbot针对PSS(即行数限制为2的BMS)完成了终止性证明<ref>https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:P%E9%80%B2%E5%A4%A7%E5%A5%BD%E3%81%8Dbot/%E3%83%9A%E3%82%A2%E6%95%B0%E5%88%97%E3%81%AE%E5%81%9C%E6%AD%A2%E6%80%A7</ref>
2018 年 11 月 11 日,P進大好きbot 针对 PSS(即行数限制为 2 的 BMS)完成了终止性证明。<ref>P shin daisuki bot (P進大好きbot) (2018). [https://googology.fandom.com/ja/wiki/%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%83%96%E3%83%AD%E3%82%B0:P%E9%80%B2%E5%A4%A7%E5%A5%BD%E3%81%8Dbot/%E3%83%9A%E3%82%A2%E6%95%B0%E5%88%97%E3%81%AE%E5%81%9C%E6%AD%A2%E6%80%A7 Stopping property of pair sequences] (ペア数列の停止性). ''Googology Wiki''.</ref>


2018年8月28日,Bubby3确认BM2确实不会终止<ref>[https://googology.fandom.com/wiki/User_blog:Bubby3/BM2_doesn%27t_terminate. https://googology.fandom.com/wiki/User_blog:Bubby3/BM2_doesn%27t_terminate.]</ref>
2018 年 8 月 28 日,Bubby3 确认 BM2 确实不会终止。<ref>Bubby3 (2018). [https://googology.fandom.com/wiki/User_blog:Bubby3/BM2_doesn%27t_terminate. BM2 doesn't terminate.]. ''Googology Wiki''.</ref>


Bashicu最终修正官方定义推出BM4,此为2018年9月1日的最新版本。该版本最终在2023年7月12日被Racheline(在googology社区中曾用名Yto)证明停机<ref>https://arxiv.org/abs/2307.04606</ref>
Bashicu 最终修正官方定义推出 BM4,此为2018 年 9 月 1 日的最新版本。该版本最终在 2023 年 7 月 12 日被 Racheline(在 googology 社区中曾用名 Yto)证明停机。<ref>Rachel Hunter (2024). [https://arxiv.org/abs/2307.04606 Well-Orderedness of the Bashicu Matrix System]. ''arXiv''.</ref>


尽管BM4是最后官方修订版,但googology社区已衍生诸多非官方变体,如BM2.2、BM2.5、BM2.6、BM3.1、BM3.1.1、BM3.2及PsiCubed2版等<ref>https://googology.fandom.com/wiki/User_blog:Ecl1psed276/A_list_of_all_BMS_versions_and_their_differences</ref>。需注意的是,整数编号版本(1-4)均由Bashicu本人定义,其余版本均为他人修改。
尽管 BM4 是最后官方修订版,但 googology 社区已衍生诸多非官方变体,如 BM2.2、BM2.5、BM2.6、BM3.1、BM3.1.1、BM3.2 及 PsiCubed2 版等。<ref>Ecl1psed276 (2018). [https://googology.fandom.com/wiki/User_blog:Ecl1psed276/A_list_of_all_BMS_versions_and_their_differences A list of all BMS versions and their differences]. ''Googology Wiki''.</ref>需注意的是,整数编号版本(1-4)均由 Bashicu 本人定义,其余版本均为他人修改。


由于BMS在三行之后出现提升效应造成分析上的极大困难,目前我们仍然在探索理想无提升BMS(Idealized BMS,IBMS)的定义。BM3.3<ref>User blog:Rpakr/Bashicu Matrix Version 3.3 | Googology Wiki | Fandom</ref>一度被认为是符合预期的IBMS,然而目前已经发现了BM3.3也具有提升。
由于 BMS 在三行之后出现提升效应造成分析上的极大困难,目前我们仍然在探索理想无提升 BMS(Idealized BMS,IBMS)的定义。[[BM3.3]]一度被认为是符合预期的 IBMS<ref>User blog:Rpakr/Bashicu Matrix Version 3.3 | Googology Wiki | Fandom</ref>,然而目前已经发现了 BM3.3 也具有提升。


=== 争议 ===
=== 争议 ===
test_alpha0声称Yto(Racheline)剽窃了他的证明。据test_alpha0所说,他在2022年2月16日在googology wiki上发布了关于BMS停机证明的文章<ref>User blog:ReflectingOrdinal/A proof of termination of BMS | Googology Wiki | Fandom</ref>,并在googology discord社区回答了相关问题,Racheline声称他的证明不严谨,但过了一段时间,Racheline在ArXiv上发了证明,框架与test_alpha0的证明完全一致。目前尚不清楚Racheline的回应。
test_alpha0 声称 Yto(Racheline)剽窃了他的证明。据t est_alpha0 所说,他在 2022 年 2 月 16 日在 googology wiki 上发布了关于 BMS 停机证明的文章<ref>User blog:ReflectingOrdinal/A proof of termination of BMS | Googology Wiki | Fandom</ref>,并在 googology discord 社区回答了相关问题,Racheline 声称他的证明不严谨,但过了一段时间,Racheline 在 ArXiv上发了证明,框架与 test_alpha0 的证明完全一致。目前尚不清楚 Racheline 的回应。


== 强度分析 ==
== 强度分析 ==
主词条:[[BMS分析]],[[提升效应]]
主词条:[[BMS分析|BMS 分析]],[[提升效应]]
 
BMS 的分析是一项浩大的工程,由于提升效应造成的困难。BMS的分析最初由Bubby3使用[[SAN]]进行,得出了<math>\text{lim(pDAN)}=(0,0,0)(1,1,1)(2,2,0)</math>,后来Yto接手了BMS的分析工作,使用[[稳定序数]]分析到了<math>(0,0,0)(1,1,1)(2,2,2)</math>。国内的YourCpper、bugit等人使用[[投影序数|投影]]进行BMS分析,达到了<math>(0,0,0,0)(1,1,1,1)(2,2,1,1)(3,0,0,0)</math>以上,但这些分析是错误的。后来FENG发现并修正了两人的分析错误,最终完成了BMS与向上投影的分析工作。


BMS的分析是一项浩大的工程,由于提升效应造成的困难,直至今日,对BMS的强度的全部分析仍然未完成。这里列举出一些关键节点:
这里列举出一些关键节点:


<math>\varnothing=0</math>
<math>\varnothing=0</math>
第136行: 第140行:


<math>(0,0,0)(1,1,1)(2,1,1)(3,1,1)=\psi(I_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,1,1)(3,1,1)=\psi(I_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,1,1)(3,1,1)(3,1,1)=\psi(M_{\omega})</math>


<math>(0,0,0)(1,1,1)(2,1,1)(3,1,1)(4,1,1)=\psi(K_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,1,1)(3,1,1)(4,1,1)=\psi(K_{\omega})</math>
第141行: 第147行:
<math>(0,0,0)(1,1,1)(2,2,0)=\psi(psd.\Pi_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,2,0)=\psi(psd.\Pi_{\omega})</math>


<math>(0,0,0)(1,1,1)(2,2,1)=\psi(\lambda\alpha.(\Omega_{\alpha+2})-\Pi_1)</math>
<math>(0,0,0)(1,1,1)(2,2,1)=\psi(\Pi_1(\lambda\alpha.(\Omega_{\alpha+2})-\Pi_1))</math>


<math>(0,0,0)(1,1,1)(2,2,1)(3,0,0)=\psi(\lambda\alpha.(\Omega_{\alpha+\omega})-\Pi_0)</math>
<math>(0,0,0)(1,1,1)(2,2,1)(3,0,0)=\psi(\lambda\alpha.(\Omega_{\alpha+\omega})-\Pi_0)</math>


<math>(0,0,0)(1,1,1)(2,2,2)=\psi(psd. \omega-\pi-\Pi_0)=\psi(\alpha_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,2,1)(3,2,1)=\psi(\Pi_1(\lambda\alpha.(I_{\alpha+1})-\Pi_1))</math>
 
<math>(0,0,0)(1,1,1)(2,2,1)(3,3,0)=\psi(\lambda\alpha.(\lambda\beta.\beta+1-\Pi_1[\alpha+1])-\Pi_1)</math>
 
<math>(0,0,0)(1,1,1)(2,2,2)=\psi(psd. \omega-\pi-\Pi_0)=\psi(\psi_\alpha(\alpha_{\omega}))</math>
 
<math>(0,0,0)(1,1,1)(2,2,2)(3,2,2)=\psi(\psi_\alpha(\alpha_{\omega^2}))</math>
 
<math>(0,0,0)(1,1,1)(2,2,2)(3,3,0)=\psi(\psi_\alpha(\psi_\beta(\varepsilon_{\alpha_{\beta+1}+1})))</math>


<math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)=\psi(\beta_{\omega})</math>
<math>(0,0,0)(1,1,1)(2,2,2)(3,3,3)=\psi(\beta_{\omega})</math>


<math>(0,0,0,0)(1,1,1,1)=\psi(\omega-Proj.)=\psi(\psi_S(\sigma S\times \omega))</math>
<math>(0,0,0,0)(1,1,1,1)=\psi(\omega-\text{Projection})=\psi(\psi_S(\sigma S\times \omega))</math>


<math>(0,0,0,0)(1,1,1,1)</math>之后,BMS和[[投影]]的列表分析还没有得到广泛。
<math>(0,0,0,0)(1,1,1,1)(2,1,1,1)(3,1,0,0)(2,0,0,0)=\psi((1,0)-\text{Projection})=\psi(\psi_S(\sigma S\times S))</math>


<math>(0,0,0,0)(1,1,1,1)</math>被命名为TSSO(Trio Sequence System Ordinal,三行序列系统序数),<math>(0,0,0,0,0)(1,1,1,1,1)</math>被命名为QSSO(Quardo Sequence System Ordinal,四行序列系统序数)。BMS的极限在中文googology社区被称为SHO(Small Hydra Ordinal),但这一命名的起源不明(SHO最早被用来指代<math>\varepsilon_0</math>,后来不明不白的变成了BMS极限),也是非正式的,因此被部分人拒绝使用。也有人称BMS极限为BMO。
<math>(0,0,0,0)(1,1,1,1)(2,1,1,1)(3,1,1,1)=\psi(\psi_S(\sigma S\times S\times\omega))</math>


== 来源 ==
<math>(0,0,0,0)(1,1,1,1)(2,2,0,0)=\psi(\psi_S(\sigma S\times S\times\omega+S_2))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,1,1)=\psi(\psi_S(\sigma S\times S\times\omega+\psi_{S_3}(\sigma S\times S\times\omega)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,0)=\psi(\psi_S(\sigma S\times S\times\omega+S_\omega))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)=\psi(\psi_S(\sigma S\times S\times\omega^2))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,0,0)(4,3,0,0)=\psi(\psi_S(\varepsilon_{\sigma S+1}))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,2,0)=\psi(\psi_S(\sigma S_\omega))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,2,1)=\psi(\psi_S(\psi_{\sigma\sigma S}(\sigma S_{\sigma \sigma S+1}^2+1)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,0,0)=\psi(\psi_S(\psi_{\sigma\sigma S}(\sigma\sigma S_2)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)=\psi(\psi_S(\psi_{\sigma\sigma S}(S_{\sigma\sigma S_2+1}+\sigma S_{\sigma\sigma S+1}\times(S+1)+\sigma S\times S \times \omega)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,2,0)=\psi(\psi_S(\psi_{\sigma\sigma S}(S_{\sigma\sigma S_2+1}+\psi_{\sigma\sigma S_2}(S_{\sigma\sigma S_2+1}+1))))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,2,1)=\psi(\psi_S(\psi_{\sigma\sigma S}(S_{\sigma\sigma S_2+2}+1)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,0)=\psi(\psi_S(\psi_{\sigma\sigma S}(\sigma\sigma S_\omega)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)=\psi(\psi_S(\sigma\sigma S\times\omega))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)(4,0,0,0)=\psi(\psi_S(\sigma\theta S\times\omega))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)(4,4,4,0)=\psi(\psi_S(\psi_{\sigma\sigma\theta S}(\sigma\sigma\theta S_\omega)))</math>
 
<math>(0,0,0,0)(1,1,1,1)(2,2,2,2)=\psi(\psi_X(\theta X\times\omega))</math>
 
<math>(0,0,0,0,0)(1,1,1,1,1)=\psi(\psi_H(H^{H^\omega}))</math>


<math>\text{Limit}=\psi(\psi_H(\varepsilon_{H+1}))</math>


<math>(0,0,0,0)(1,1,1,1)</math>被命名为 TSSO(Trio Sequence System Ordinal,三行序列系统序数),<math>(0,0,0,0,0)(1,1,1,1,1)</math>被命名为 QSSO(Quardo Sequence System Ordinal,四行序列系统序数)。BMS 的极限在中文 googology 社区被称为 SHO(Small Hydra Ordinal),但这一命名的起源不明(SHO 最早被用来指代 <math>\varepsilon_0</math>,后来不明不白的变成了 BMS 极限),也是非正式的,因此被部分人拒绝使用。也有人称 BMS 极限为 BMO。


== 来源 ==
{{默认排序:序数记号}}
[[分类:记号]]
[[分类:记号]]

2025年8月30日 (六) 21:31的最新版本

Bashicu 矩阵系统(Bashicu Matrix System,BMS)是一个序数记号。Bashicu Hyudora 在 2018 年给出了它的定义。直至今日,BMS 依然是已经证明良序的最强的序数记号。

定义

原定义

Bashicu 最初在他的未命名的 BASIC 编程语言改版上提交了 BMS 的定义。[1]BMS 的原定义是一个大数记号,理论的输出是一个大数。该程序并未设计为实际运行,原因在于语言修改的未定义性,同时也受限于内存与计算时间的现实约束,无法计算出这个大数的实际最终值。因此,Fish 编写了名为"Bashicu 矩阵计算器"的程序来演示预期的计算流程(该程序已得到 Bashicu 验证)。故 Bashicu 矩阵的正式定义可参考 Fish 程序的源代码。[2]

正式定义

中文 googology 社区提到 BMS 默认是一个序数记号。以下是序数记号 BMS 的定义及说明:

首先是 BMS 合法式:BMS 的合法式是二维的自然数构成的序列,在外观上看是一个矩阵。如 (012101110101) 就是一个 BMS 的合法式。在很多场合,这种二维的结构书写起来不是很方便,因此我们也常常把BMS从左到右、从上到下按列书写,每一列的不同行之间用逗号隔开,不同列之间用括号隔开。例如,上面的 BMS 也可以写成 (0,0,0)(1,1,1)(2,1,0)(1,1,1)。在很多情况下,除首列外,列末的 0 也可以省略不写,例如上面的 BMS 写为 (0)(1,1,1)(2,1)(1,1,1)

理论上来说,只要是这样的式子就可以按照 BMS 的规则进行处理了。但实际操作过程中,我们还可以排除一些明显不标准的式子:

  • 首列并非全 0
  • 每一列并非不严格递减,即出现一列中下面的数大于上面的数
  • 出现一个元素 a,它比它同行左边所有元素都大超过 1

在了解 BMS 的展开规则之前,需要先了解一些概念。

  1. 第一行元素的父项:对于位于第一行的元素 a,它的父项 b 是满足以下条件的项当中,位于最右边的项:1. 同样位于第一行且在 a 的左边;2. 小于 a。这里和 PrSS 判定父项的规则是相同的。显然,0 没有父项。
  2. 祖先项:一个元素自己,以及它的父项、父项的父项、父项的父项的父项……共同构成它的祖先项。
  3. 其余行元素的父项:对于不位于第一行的元素 c,它的父项 d 指满足以下条件的项当中,位于最右边的项:1. 与c位于同一行且在 c 的左边;2. 小于 c;3. d 正上方的项 e 是 c 正上方的项f的祖先项。0 没有父项。
  4. 坏根:最后一列位于最下方的非零元素的父项所在列,称为坏根。如果最后一列所有元素为 0,则这个 BMS 表达式无坏根。值得一提的是,末列最靠下的非零元素记作 LNZ(Lowermost Non-Zero)
  5. 好部坏部:这两个概念与 PrSS 是相似的。位于坏根左边的所有列称为好部,记作 G,G 可以为空;从坏根到倒数第二列(包括坏根、倒数第二列)的部分称为坏部,记作B。
  6. 阶差向量:在一个 n 行 BMS 中,我们把末列记为 (α1,α2,,αn),把坏根列记为 (β1,β2,,βn),并且我们规定 αn+1=0。则阶差向量Δ=(δ1,δ2,,δn)按照这样的规则得到:δi={αiβi,αi+100,αi+1=0。通俗的说,如果末列的第 i+1 项等于0,则 δi=0,否则 δi 等于末列第 i 行减去坏根列第 i 行。阶差向量记作 Δ
  7. BmBm是 B 中每一列都加上 Δ 的 m 倍所得到的新矩阵。但是有一点需要注意:如果 B 中某个元素 t 的祖先项不包含坏根中的元素,则在 Bm 对应位置的元素的值依然是 t,它不加 Δ

了解概念后,以下是 BMS 的展开规则:

  1. 空矩阵 = 0
  2. 如果表达式是非空矩阵 S,如果它没有坏根,那么 S 等于 S 去掉最后一列之后,剩余部分的后继 。
  3. 否则,确定这个 BMS 表达式 S 的坏根、G、B、Δ,S 的基本列第 n 项S[n]=GBB1B2B3Bn1。其中 ~ 表示序列拼接。或者称 S 的展开式是 GBB1B2ω

BMS 的极限基本列是 {(0)(1),(0,0)(1,1),(0,0,0)(1,1,1),(0,0,0,0)(1,1,1,1),},从这个基本列中元素开始取前驱或取基本列所能得到的表达式是 BMS 的标准式。

以下是 BMS 展开的一些实例:

例一:(0,0,0)(1,1,1)(2,2,1)(3,2,0)(0,0,0)

因为末列全都是 0,因此这个 BMS 没有坏根。根据规则 2,它是 (0,0,0)(1,1,1)(2,2,1)(3,2,0) 的后继。

例二:(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,2,0)

LNZ 是末列第二行的 2。首先确定末列第 1 行元素的祖先项,即标红的部分(末列本身不染色,下同):(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,2,0)。因此末列第二行的 2 的父项只能在含有标红元素的这些列中选取。于是确定 LNZ 的父项为(标绿):(0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,2,0)。因此确定 (1,1,1) 是坏根。好部 G 是 (0,0,0),坏部 B 是 (1,1,1)(2,2,2)(3,3,3)。计算出阶差向量 Δ=(3,0,0)。检查 B 中是否存在祖先项不包含坏根中元素的项(当然,我们只需要检查 Δ 非零的那些行),很幸运,没有。于是我们得到展开式是 (0,0,0)(1,1,1)(2,2,2)(3,3,3)(4,1,1)(5,2,2)(6,3,3)(7,1,1)(8,2,2)(9,3,3)

例三:(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)

LNZ 是末列第四行的 1。首先确定末列第一行元素 7 的祖先项(标红):(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)。在含有标红元素的列中寻找末列第二行元素 3 的祖先项(标绿):(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)。在含有标绿元素的列中寻找末列第三行元素 1 的祖先项(标蓝):(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,1)。在含有标蓝元素的列中寻找 LNZ 的父项,即首列第四行的 0。于是得到坏根是 (0,0,0,0),好部 G 是空矩阵,坏部 B 是 (0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1),计算阶差向量 Δ=(7,3,1,0)。检查 B 中是否存在祖先项不包含坏根中元素的项(只检查 Δ 非 0 的行)得到第五列第三行的 0 祖先项不经过坏根。于是我们得到展开式是

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)(4,2,0,0)(5,1,1,1)(6,2,2,1)(7,3,1,0)(8,4,2,1)(9,5,3,1)(10,6,2,1)(11,5,0,0)(12,4,2,1)(13,5,3,1)(14,6,2,0)(15,7,3,1)(16,8,4,1)(17,9,3,1)(18,8,0,0)(19,7,3,1)(20,8,4,1)

展开 BMS 可以靠 Bashicu Matrix CalculatorNotation Explorer 辅助。

数学定义

kotetian 给出 BMS 的数学定义,但是他给出的定义是大数记号版本的。以下是根据他的定义改写的序数记号版 BMS 的定义:

Matrix:S=S0S1SX1

Vector:Sx=(Sx0,Sx1,,Sx(Y1))

parentofSxy:Py(x)={max{p|p<xSpy<Sxya(p=(Py1)a(x))}if y>0max{p|p<xSpy<Sxy}if y=0

Lowermostnonzero:t=max{y|S(X1)y>0}

Badroot:r=Pt(X1)

Ascensionoffset:Δy={S(X1)ySryif y<t0if yt

Ascensionmatrix:Axy={1(ifa(r=(Py)a(r+x)))0(otherwise)

Goodpart:G=S0S1Sr1

Badpart:B(a)=B0(a)B1(a)BX2r(a)

Bx(a)=(Bx0(a),Bx1(a),,Bx(Y1)(a))

Bxy(a)=S(r+x)y+aΔyAxy

=0

S={S0S1S2SX2,if y,S(X1)y=0sup{G,GB(0),GB(0)B(1),GB(0)B(1)B(2),}otherwise

历史

Bashicu 在2015年的时候给出了第一版 BMS 的定义,即 BM1。BM1 创建后的首个问题便是其是否必然终止。这一疑问直到 2016 年用户 KurohaKafka 在日本论坛 2ch.net 发表终止性证明才暂告段落。[3]然而 Hyp cos 通过构造非终止序列推翻了该证明。[4]

为此,Bashicu 发布第二版(BM2),以 BASIC 语言重新实现算法。[1]2018年6月12日,他再次更新定义至 BM3,[5]但当月内 Alemagno12 便发现存在不终止的例证。[6]

2018 年 11 月 11 日,P進大好きbot 针对 PSS(即行数限制为 2 的 BMS)完成了终止性证明。[7]

2018 年 8 月 28 日,Bubby3 确认 BM2 确实不会终止。[8]

Bashicu 最终修正官方定义推出 BM4,此为2018 年 9 月 1 日的最新版本。该版本最终在 2023 年 7 月 12 日被 Racheline(在 googology 社区中曾用名 Yto)证明停机。[9]

尽管 BM4 是最后官方修订版,但 googology 社区已衍生诸多非官方变体,如 BM2.2、BM2.5、BM2.6、BM3.1、BM3.1.1、BM3.2 及 PsiCubed2 版等。[10]需注意的是,整数编号版本(1-4)均由 Bashicu 本人定义,其余版本均为他人修改。

由于 BMS 在三行之后出现提升效应造成分析上的极大困难,目前我们仍然在探索理想无提升 BMS(Idealized BMS,IBMS)的定义。BM3.3一度被认为是符合预期的 IBMS[11],然而目前已经发现了 BM3.3 也具有提升。

争议

test_alpha0 声称 Yto(Racheline)剽窃了他的证明。据t est_alpha0 所说,他在 2022 年 2 月 16 日在 googology wiki 上发布了关于 BMS 停机证明的文章[12],并在 googology discord 社区回答了相关问题,Racheline 声称他的证明不严谨,但过了一段时间,Racheline 在 ArXiv上发了证明,框架与 test_alpha0 的证明完全一致。目前尚不清楚 Racheline 的回应。

强度分析

主词条:BMS 分析提升效应

BMS 的分析是一项浩大的工程,由于提升效应造成的困难。BMS的分析最初由Bubby3使用SAN进行,得出了lim(pDAN)=(0,0,0)(1,1,1)(2,2,0),后来Yto接手了BMS的分析工作,使用稳定序数分析到了(0,0,0)(1,1,1)(2,2,2)。国内的YourCpper、bugit等人使用投影进行BMS分析,达到了(0,0,0,0)(1,1,1,1)(2,2,1,1)(3,0,0,0)以上,但这些分析是错误的。后来FENG发现并修正了两人的分析错误,最终完成了BMS与向上投影的分析工作。

这里列举出一些关键节点:

=0

(0)=1

(0)(0)=2

(0)(1)=ω

(0)(1)(1)=ω2

(0)(1)(2)=ωω

(0,0)(1,1)=ε0

(0,0)(1,1)(1,1)=ε1

(0,0)(1,1)(2,0)=εω

(0,0)(1,1)(2,1)=ζ0

(0,0)(1,1)(2,2)=ψ(Ω2)

(0,0,0)(1,1,1)=ψ(Ωω)

(0,0,0)(1,1,1)(2,1,0)=ψ(Ωω×Ω)

(0,0,0)(1,1,1)(2,1,0)(1,1,1)=ψ(Ωω2)

(0,0,0)(1,1,1)(2,1,1)=ψ(Ωω2)

(0,0,0)(1,1,1)(2,1,1)(3,1,0)(2,0,0)=ψ(I)

(0,0,0)(1,1,1)(2,1,1)(3,1,1)=ψ(Iω)

(0,0,0)(1,1,1)(2,1,1)(3,1,1)(3,1,1)=ψ(Mω)

(0,0,0)(1,1,1)(2,1,1)(3,1,1)(4,1,1)=ψ(Kω)

(0,0,0)(1,1,1)(2,2,0)=ψ(psd.Πω)

(0,0,0)(1,1,1)(2,2,1)=ψ(Π1(λα.(Ωα+2)Π1))

(0,0,0)(1,1,1)(2,2,1)(3,0,0)=ψ(λα.(Ωα+ω)Π0)

(0,0,0)(1,1,1)(2,2,1)(3,2,1)=ψ(Π1(λα.(Iα+1)Π1))

(0,0,0)(1,1,1)(2,2,1)(3,3,0)=ψ(λα.(λβ.β+1Π1[α+1])Π1)

(0,0,0)(1,1,1)(2,2,2)=ψ(psd.ωπΠ0)=ψ(ψα(αω))

(0,0,0)(1,1,1)(2,2,2)(3,2,2)=ψ(ψα(αω2))

(0,0,0)(1,1,1)(2,2,2)(3,3,0)=ψ(ψα(ψβ(εαβ+1+1)))

(0,0,0)(1,1,1)(2,2,2)(3,3,3)=ψ(βω)

(0,0,0,0)(1,1,1,1)=ψ(ωProjection)=ψ(ψS(σS×ω))

(0,0,0,0)(1,1,1,1)(2,1,1,1)(3,1,0,0)(2,0,0,0)=ψ((1,0)Projection)=ψ(ψS(σS×S))

(0,0,0,0)(1,1,1,1)(2,1,1,1)(3,1,1,1)=ψ(ψS(σS×S×ω))

(0,0,0,0)(1,1,1,1)(2,2,0,0)=ψ(ψS(σS×S×ω+S2))

(0,0,0,0)(1,1,1,1)(2,2,1,1)=ψ(ψS(σS×S×ω+ψS3(σS×S×ω)))

(0,0,0,0)(1,1,1,1)(2,2,2,0)=ψ(ψS(σS×S×ω+Sω))

(0,0,0,0)(1,1,1,1)(2,2,2,1)=ψ(ψS(σS×S×ω2))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,0,0)(4,3,0,0)=ψ(ψS(εσS+1))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,2,0)=ψ(ψS(σSω))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,2,2,1)=ψ(ψS(ψσσS(σSσσS+12+1)))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,0,0)=ψ(ψS(ψσσS(σσS2)))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,1,1)=ψ(ψS(ψσσS(SσσS2+1+σSσσS+1×(S+1)+σS×S×ω)))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,2,0)=ψ(ψS(ψσσS(SσσS2+1+ψσσS2(SσσS2+1+1))))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,2,1)=ψ(ψS(ψσσS(SσσS2+2+1)))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,0)=ψ(ψS(ψσσS(σσSω)))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)=ψ(ψS(σσS×ω))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)(4,0,0,0)=ψ(ψS(σθS×ω))

(0,0,0,0)(1,1,1,1)(2,2,2,1)(3,3,3,1)(4,4,4,0)=ψ(ψS(ψσσθS(σσθSω)))

(0,0,0,0)(1,1,1,1)(2,2,2,2)=ψ(ψX(θX×ω))

(0,0,0,0,0)(1,1,1,1,1)=ψ(ψH(HHω))

Limit=ψ(ψH(εH+1))

(0,0,0,0)(1,1,1,1)被命名为 TSSO(Trio Sequence System Ordinal,三行序列系统序数),(0,0,0,0,0)(1,1,1,1,1)被命名为 QSSO(Quardo Sequence System Ordinal,四行序列系统序数)。BMS 的极限在中文 googology 社区被称为 SHO(Small Hydra Ordinal),但这一命名的起源不明(SHO 最早被用来指代 ε0,后来不明不白的变成了 BMS 极限),也是非正式的,因此被部分人拒绝使用。也有人称 BMS 极限为 BMO。

来源

  1. 1.0 1.1 Bashicu Hyudora (2015). Summary of large numbers in BASIC language (BASIC言語による巨大数のまとめ). Googology Wiki.
  2. Kyodaisuu (2020). basmat. Gthub.
  3. http://wc2014.2ch.net/test/read.cgi/math/1448211924/152-155n
  4. Hyp cos (2016). Talk: Bashicu Matrix System, Something wrong happens. Googology Wiki.
  5. Kyodaisuu (2018). Bashiku Matrix Version 3 (バシク行列バージョン3). Googology Wiki.
  6. Alemagno12 (2018). BM3 has an infinite loop. Googology Wiki.
  7. P shin daisuki bot (P進大好きbot) (2018). Stopping property of pair sequences (ペア数列の停止性). Googology Wiki.
  8. Bubby3 (2018). BM2 doesn't terminate.. Googology Wiki.
  9. Rachel Hunter (2024). Well-Orderedness of the Bashicu Matrix System. arXiv.
  10. Ecl1psed276 (2018). A list of all BMS versions and their differences. Googology Wiki.
  11. User blog:Rpakr/Bashicu Matrix Version 3.3 | Googology Wiki | Fandom
  12. User blog:ReflectingOrdinal/A proof of termination of BMS | Googology Wiki | Fandom