BAN - 版本历史

2025年8月20日 (三) 08:06 Z

2025-08-20T08:06:43Z

←上一版本		2025年8月20日 (三) 16:06的版本
第762行：		第762行：
	#* θ(Ω_(ω^ω)+1): [1 [1 /1 [2] 2 3] 2]（规则A5b）		#* θ(Ω_(ω^ω)+1): [1 [1 /1 [2] 2 3] 2]（规则A5b）
	# 三步算法：规则A5a中，算法通过比较[Bj]和[Dj]层级确定Nn,s，直至找到解。		# 三步算法：规则A5a中，算法通过比较[Bj]和[Dj]层级确定Nn,s，直至找到解。
			{{默认排序:大数记号}}
	[[分类:记号]]		[[分类:记号]]

Tabelog：/* 定义 */

2025-08-03T16:59:31Z

定义

←上一版本		2025年8月4日 (一) 00:59的版本
第1行：		第1行：
	'''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 [[BEAF]] 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。		'''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 [[BEAF]] 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。

	== 定义 ~~& 教学~~ ==		== 定义 ==

	=== 线性数阵记号（Bird’s Linear Array Notation） ===		=== 线性数阵记号（Bird’s Linear Array Notation） ===
第20行：		第20行：

	=== 多维数阵记号（Bird’s Multi-Dimensional Array Notation） ===		=== 多维数阵记号（Bird’s Multi-Dimensional Array Notation） ===
			多维数阵记号有 7 条操作规则：

			* Rule 1 (仅 1 或 2 项，均在第一个 1-空间): {a} = a, {a, b} = a^b.
			* Rule 2 (数组的任何 1 维或更高维空间中的最后一项是 1): {#[a]1}={#}. 当 a＜b 时，{#[a]1[b]#}={#[b]#} (删除 (b-1)-空间的尾随的 1)
			* Rule 3 (第二项是 1 或第一个 1-空间只有 1 项): {a, 1 #} = a. 当 b≥2 时，{a [b] #} = a.
			* Rule 4 (第一个 1-空间只有 2 项，下一个非 1 项 (c) 不是它所在的 1-空间的第一项): {a, b [n1] 1 [n2] 1 [n3] ... 1 [nk] 1, c #} = {a ‹n1-1› b [n1] a ‹n2-1› b [n2] ... a ‹nk-1› b [nk] R, c-1 #}. 其中 R = {a, b-1 [n1] 1 [n2] 1 [n3] ... 1 [nk] 1, c #}.

			n1≥2（因为 [n1] 紧接在第一个 1-空间之后），n1≥n2≥...≥nk（根据规则 2）。对应于 1 的完整字符串的最后一个 1 的项被整个数阵的副本替换，其第二项被减少 1。对于每个 1≤i≤k 的情况，[ni] 分隔符之前的 1（i=1 时为 a,b）被 a 的 (ni-1) 维 b^(ni-1) 串所取代。

			* Rule 5 (第一个 1-空间只有 2 项，下一个非 1 项 (c) 是它所在的 1-空间的第一项): {a, b [n1] 1 [n2] 1 [n3] ... 1 [nk] c #} = {a ‹n1-1› b [n1] a ‹n2-1› b [n2] ... a ‹nk-1› b [nk] c-1 #}.

			nk≥2（因为 [nk] 紧接在 1-空间的开始之前），n1≥n2≥...≥nk≥2（根据规则 2）。与规则 4 类似，除了在 1 的完整字符串中的 1 后面没有逗号。未中断字符串的最后一个 1 被 a 的 (nk-1) 维 b^(nk-1) 字符串替换。

	=== 超维数阵记号（Bird’s Hyper-Dimensional Array Notation） ===		=== 超维数阵记号（Bird’s Hyper-Dimensional Array Notation） ===

2025年8月3日 (日) 16:49 Tabelog

2025-08-03T16:49:10Z

@@ 第1行： / 第1行： @@
 '''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 [[BEAF]] 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。
-== 定义 ==
+== 定义 & 教学 ==
 === “简单”数阵 ===

2025年7月30日 (三) 04:46 Z

2025-07-30T04:46:43Z

←上一版本		2025年7月30日 (三) 12:46的版本
第726行：		第726行：
	#* θ(Ω_(ω^ω)+1): [1 [1 /1 [2] 2 3] 2]（规则A5b）		#* θ(Ω_(ω^ω)+1): [1 [1 /1 [2] 2 3] 2]（规则A5b）
	# 三步算法：规则A5a中，算法通过比较[Bj]和[Dj]层级确定Nn,s，直至找到解。		# 三步算法：规则A5a中，算法通过比较[Bj]和[Dj]层级确定Nn,s，直至找到解。
			[[分类:记号]]

2025年7月24日 (四) 15:03 Tabelog

2025-07-24T15:03:18Z

显示更改

2025年7月24日 (四) 14:31 Tabelog

2025-07-24T14:31:57Z

显示更改

2025年7月24日 (四) 13:43 Tabelog

2025-07-24T13:43:05Z

@@ 第66行： / 第66行： @@
 === 超嵌套数阵：反斜杠数阵 ===
 === 嵌套超嵌套数阵 ===
 ==== 2-超分离器 ====
 ==== 2 超分隔符数组 ====
 === 嵌套超嵌套数阵表示法 ===

Tabelog：创建页面，内容为“'''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 BEAF 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。 == 定义 == === “简单”数阵 === ==== 线性和多维数阵 ==== * '''规则 1'''. 若有一或两个元素，则有 $\{a\} = a,\{a,b\} = a^b$ * '''规则 2'''. 若最后一个元素为 1，则可…”

2025-07-24T13:02:31Z

创建页面，内容为“'''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 BEAF 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。 == 定义 == === “简单”数阵 === ==== 线性和多维数阵 ==== * '''规则 1'''. 若有一或两个元素，则有 <math>\{a\} = a,\{a,b\} = a^b</math> * '''规则 2'''. 若最后一个元素为 1，则可…”

新页面

'''Bird 数组表示法'''（Bird's Array Notation,BAN）是由 Chris Bird 发明的一种大数记号。它是 [[BEAF]] 的扩展，无论是在历史上还是在定义上都类似于 BEAF，但与 BEAF 略有不同，使其更加“简单”。

== 定义 ==

=== “简单”数阵 ===

==== 线性和多维数阵 ====

* '''规则 1'''. 若有一或两个元素，则有 <math>\{a\} = a,\{a,b\} = a^b</math>
* '''规则 2'''. 若最后一个元素为 1，则可将其去掉：<math>\{\# 1\} = \{\#\}</math>
* '''规则 3'''. 若第二个元素为 1，则该数阵的值即为第一个元素：<math>\{a,1 \#\} = a</math>
* '''规则 4'''. 若第三个元素为 1：
<math>\{a,b,1,1,\cdots,1,1,c \#\} = \{a,a,a,a,\cdots,a,\{a,b-1,1,1,\cdots,1,1,c \#\},c-1 \#\}</math>
* '''规则 5'''. 其他情况：
<math>\{a,b,c \#\} = \{a,\{a,b-1,c \#\},c-1 \#\}</math>

对于多维数阵，Bird 使用 <math>a \langle c \rangle b</math>，它与 BEAF 的 <math>b^c \& a</math> 等价。这些字符串写在引号内，且有其特定的规则：

* '''规则 A1'''. 若 <math>c = 0</math>，则有 <math>a \langle 0 \rangle b = a</math>
* '''规则 A2'''. 若 <math>b = 1</math>，则有 <math>a \langle c \rangle 1 = a</math>
* '''规则 A3'''. 其他情况，<math>a \langle c \rangle b = a \langle c - 1 \rangle b [c] a \langle c \rangle (b - 1)</math>

主要规则如下：

* '''规则 M1'''. 若只有两个元素，则 <math>\{a, b\} = a^b</math>
* '''规则 M2'''. 若 <math>m<n</math>，则有 <math>\{\# [m] 1 [n] \#*\} = \{\# [n] \#*\}</math>（另外，<math>\{\# [a] 1\} = \{\#\}</math>）
* '''规则 M3'''. 若第二个元素为 1，则有 <math>\{a,1 \#\} = a</math>
* '''规则 M4'''. 若 <math>m_1 \geq 2</math> 且 <math>m_1 \geq \cdots \geq m_x</math>，则有
<math>\{a,b [m_1] 1 [m_2] \cdots 1 [m_x] c \#\} = \{a \langle m_1-1 \rangle b [m_1] a \langle m_2-1 \rangle b [m_2] \cdots a \langle m_x-1 \rangle b [m_x] (c-1) \#\}</math>
* '''规则 M5'''. 若 <math>m_1 \geq \cdots \geq m_x \geq 2</math>，则有
<math>\{a,b [m_1] 1 [m_2] \cdots 1 [m_x] 1,c \#\} = \{a \langle m_1-1 \rangle b [m_1] a \langle m_2-1 \rangle b [m_2] \cdots a \langle m_x-1 \rangle b [m_x] \{a,b-1 [m_1] 1 [m_2] \cdots 1 [m_x] 1,c \#\},c-1 \#\}</math>
* '''规则 M6'''. 若规则 M1-M5 均不适用，则 <math>\{a,b,c \#\} = \{a,\{a,b-1,c \#\},c-1 \#\}</math>

Bird 使用 <math>[m]</math> 作为维度分隔符；在 BEAF 中，它相当于一个 <math>(m-1)</math>。

==== 超维及嵌套数阵 ====
接下来，括号分隔符变为数阵（如 <math>[1, 1, 2]</math>）。除将 <math>[m_n]</math> 替换为 <math>[m_n \#]</math> 外，规则 M1 至 M6 保持不变。

尖括号规则需要一些修改。规则 A3 变为 A4，并新增规则 A3：

* '''规则 A3'''. 若尖括号中的第一个元素为零，且其后存在非零元素：
<math>a \langle 0,1,1,\cdots,1,1,c \# \rangle b = a \langle b,b,b,\cdots,b,b,c-1 \# \rangle b</math>

此规则在视觉上与规则 M4 相似。

下一步是允许在数阵内出现字符串，从而定义嵌套数阵表示法。规则 A3 变为 A4，规则 A4 变为 A5。然后我们新增一条 A3 规则并对 A4 进行推广：

* '''规则 A3'''. 若 <math>[A] < [B]</math>，则有 <math>a \langle\# [A] 1 [B] \#^*\rangle b = a \langle\# [B] \#^*\rangle b</math>
* '''规则 A4'''. 若尖括号中的第一个元素为零，且其后存在非零元素：
<math>a \langle 0 [x_1 \#_1] 1 [x_2 \#_2] \cdots 1 [x_n \#_n] c \# \rangle b = a \langle b \langle x_1-1 \#_1 \rangle b [x_1 \#_1] b \langle x_2-1 \#_2 \rangle b [x_2 \#_2] \cdots b \langle x_n-1 \#_n \rangle b [x_n \#_n] c-1 \# \rangle b</math>

An 和 B 为数阵，且除第一个元素减一外，Ai-1 与 Ai 完全相同。

==== 两个分隔符的排序算法 ====
对于规则 A3 和 M2，确定哪个分隔符的层级更高十分重要。首先，将相互嵌套的数阵数量定义为数阵的嵌套层级。我们可以用 Lev(A) 表示。例如，若 A = {3,3[1[1[2]2]2]2}，则 Lev(A) = 3，因为 [2] 嵌套在 [1[2]2] 中，而[1[2]2]又嵌套在 [1[1[2]2]2] 中，最后 [1[1[2]2]2] 嵌套在主数阵中。非正式地说，Lev(A) 是我们需要说“嵌套”的次数，才能从最内层数阵说到主数阵。另一个函数 Num(H,A) 定义为数阵 A 中分隔符 [H] 的数量，例如，若 A = {3,3[1[2]1[2]1[2]2]2}，则 Num(2,A) = 3。

假设我们想要确定哪个分隔符的层级更高，[A] 还是 [B]。正式描述如下：

# 为进一步说明，设 [A1]=[A]，[A2]=[A1]，[B1]=[B]，[B2]=[B1]。
# 若 Lev(A)>Lev(B)，则得出 [A]>[B]；若 Lev(A)<Lev(B)，则 [A]<[B]。若 Lev(A)=Lev(B)>0，则进入步骤 3，否则进入步骤 6。
# 设 [A*] 和 [B*] 分别为数阵 A2 和 B2 中的最高层级分隔符。若 [A*]>[B*]，则 [A]>[B]；若 [A*]<[B*]，则 [A]<[B]；否则取 [H]=[A*]=[B*] 并进入步骤 4。
# 若 Num(H,A2)>Num(H,B2)，则 [A]>[B]；若 Num(A)>Num(B)，若 Num(H,A2)<Num(H,B2)，则 [A]<[B]；否则进入步骤 5。
# 在字符串 A2 和 B2 中，删除 [H] 分隔符并移除其之前的所有元素。
# 根据上述所有规则，字符串 A2 和 B2 必须为 [a] 和 [b] 的形式，其中 a 和 b 为单个数字。因此，若 a<b，则 [A]<[B]；若 a>b，则 [A]>[B]；否则进入步骤 7。
# 在字符串 A1 和 B1 中删除最后一个元素及其前的分隔符。若 A1 和 B1 为空，则得出 [A]=[B]；否则返回步骤 2。

=== 超嵌套数阵：反斜杠数阵 ===

=== 嵌套超嵌套数阵 ===

==== 2-超分离器 ====

==== 2 超分隔符数组 ====

=== 嵌套超嵌套数阵表示法 ===

==== 尖括号规则（BNA3） ====

==== 分层超嵌套数阵表示法（第 2 部分） ====

==== Bird 的分层超嵌套数阵表示法——尖括号规则 ====

=== 分层超嵌套数阵表示法 ===

==== Bird 的嵌套分层超嵌套数组表示法——尖括号规则 ====