TrSS - 版本历史

2026年2月25日 (三) 13:53 Z

2026-02-25T13:53:08Z

←上一版本		2026年2月25日 (三) 21:53的版本
第1行：		第1行：
			'''''前排提醒：本词条尚未完善'''''

	== Tree Sequence System（v1.2） ==		== Tree Sequence System（v1.2） ==

2025年8月24日 (日) 11:13 油手就行

2025-08-24T11:13:57Z

显示更改

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

2025-08-20T08:30:26Z

←上一版本		2025年8月20日 (三) 16:30的版本
第81行：		第81行：

	7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。		7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。
	[[分类:~~个人记号~~]]
			{{默认排序:个人记号}}
			[[分类:记号]]

2025年8月19日 (二) 12:00 Phyrion

2025-08-19T12:00:37Z

←上一版本		2025年8月19日 (二) 20:00的版本
第81行：		第81行：

	7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。		7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。
			[[分类:个人记号]]

2025年8月19日 (二) 11:44 油手就行

2025-08-19T11:44:20Z

←上一版本		2025年8月19日 (二) 19:44的版本
第26行：		第26行：
	2）从m=0开始，将每个数组的每个(m-1)级子数组按其中的m级分隔符分开，分开后的部分称为原数组的m级子数组。如果数组的m级子数组内仍有分隔符，那么进入3）；如果数组的m级子数组内没有分隔符，那么流程结束。（展开时用到的子数组不一定是最高等级的）		2）从m=0开始，将每个数组的每个(m-1)级子数组按其中的m级分隔符分开，分开后的部分称为原数组的m级子数组。如果数组的m级子数组内仍有分隔符，那么进入3）；如果数组的m级子数组内没有分隔符，那么流程结束。（展开时用到的子数组不一定是最高等级的）

	3）使m的值+~~1，然后回到2）~~		3）使m的值+1，然后回到2）。

			例如，
	(2,1/2/1)的0级子数组为(2,1)(/2)(/1)，1级子数组为(2)(,1)(/2)(/1)		(2,1/2/1)的0级子数组为(2,1)(/2)(/1)，1级子数组为(2)(,1)(/2)(/1)

2025年8月19日 (二) 11:42 油手就行

2025-08-19T11:42:00Z

←上一版本		2025年8月19日 (二) 19:42的版本
第9行：		第9行：
	TrSS的极限表达式为(1)(ω)。作为新型记号的首次尝试，此记号可能有不完善之处，请指出并联系我修改。		TrSS的极限表达式为(1)(ω)。作为新型记号的首次尝试，此记号可能有不完善之处，请指出并联系我修改。
	油手就行		油手就行

	更新日志：		更新日志：

	2025.8.18 TrSS v1.0		2025.8.18 TrSS v1.0

	TrSS正式被定义。		TrSS正式被定义。

	2025.8.19 TrSS v1.1		2025.8.19 TrSS v1.1

	修改了寻找坏根的方法。		修改了寻找坏根的方法。
	=== 一．前置定义 ===		=== 一．前置定义 ===
	1.子数组：		1.子数组：

	1）一个数组的-1级子数组是它本身。		1）一个数组的-1级子数组是它本身。

	2）从m=0开始，将每个数组的每个(m-1)级子数组按其中的m级分隔符分开，分开后的部分称为原数组的m级子数组。如果数组的m级子数组内仍有分隔符，那么进入3）；如果数组的m级子数组内没有分隔符，那么流程结束。（展开时用到的子数组不一定是最高等级的）		2）从m=0开始，将每个数组的每个(m-1)级子数组按其中的m级分隔符分开，分开后的部分称为原数组的m级子数组。如果数组的m级子数组内仍有分隔符，那么进入3）；如果数组的m级子数组内没有分隔符，那么流程结束。（展开时用到的子数组不一定是最高等级的）

	3）使m的值+1，然后回到2）		3）使m的值+1，然后回到2）
	(2,1/2/1)的0级子数组为(2,1)(/2)(/1)，1级子数组为(2)(,1)(/2)(/1)		(2,1/2/1)的0级子数组为(2,1)(/2)(/1)，1级子数组为(2)(,1)(/2)(/1)

	2.元素：数组(的子数组)的元素是其中的所有数和分隔符。		2.元素：数组(的子数组)的元素是其中的所有数和分隔符。

	3.末数组：表达式中最后一个数组。		3.末数组：表达式中最后一个数组。

	4.末项/分隔符：数组中最后一个数/分隔符。		4.末项/分隔符：数组中最后一个数/分隔符。
	=== 二．展开流程 ===		=== 二．展开流程 ===
	1.#(1)=#+1		1.#(1)=#+1

	2.在末数组不为(1)时：		2.在末数组不为(1)时：

	1）从n=(表达式中出现的最高等级分隔符的等级)开始，取每个数组的n级子数组。		1）从n=(表达式中出现的最高等级分隔符的等级)开始，取每个数组的n级子数组。

	①若末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么使末数组的末项等级-1，此时：		①若末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么使末数组的末项等级-1，此时：

	Ⅰ.若末项和末分隔符等级都为0，则将二者都删去。		Ⅰ.若末项和末分隔符等级都为0，则将二者都删去。

	Ⅱ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。		Ⅱ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。

	然后进入6），否则进入②。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入2）。		然后进入6），否则进入②。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入2）。

	②使n的值-1并回到①。		②使n的值-1并回到①。
	(2,1/2)和(2,1/2)的-1级子数组相同，和(2,1/2/2)的0级子数组部分相同		(2,1/2)和(2,1/2)的-1级子数组相同，和(2,1/2/2)的0级子数组部分相同
	~~# 有序列表项~~

	2）将末数组的末项和末分隔符中不为0的元素等级-1。		2）将末数组的末项和末分隔符中不为0的元素等级-1。
第51行：		第68行：
	④进入5）。		④进入5）。
	4）定义阶伸项Q为{原末数组，其中末项-1}∪{(原末数组的末项-2)级分隔符}，坏部B为[表达式第二个数组，表达式倒数第二个数组]，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。		4）定义阶伸项Q为{原末数组，其中末项-1}∪{(原末数组的末项-2)级分隔符}，坏部B为[表达式第二个数组，表达式倒数第二个数组]，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。

	5）定义坏部B为[坏根，表达式倒数第二个数组]，好部G为[表达式首项，坏根)，阶伸项Q为将(坏根与经过1）或2）操作的末数组相比缺少的部分)还原为数组的结果。		5）定义坏部B为[坏根，表达式倒数第二个数组]，好部G为[表达式首项，坏根)，阶伸项Q为将(坏根与经过1）或2）操作的末数组相比缺少的部分)还原为数组的结果。
	Ⅰ.对于坏部中原本属于3）中提到的&_i中的数组，每次复制时将Q放在坏根的对应位置之后。此时Q的开头一定是分隔符，末尾一定是数。		Ⅰ.对于坏部中原本属于3）中提到的&_i中的数组，每次复制时将Q放在坏根的对应位置之后。此时Q的开头一定是分隔符，末尾一定是数。
第57行：		第75行：
	②若某数组不能找到与坏根前面部分相同的n级子数组，在它们前面都添加坏根的内容，中间的分隔符等级与坏根的末项等级相同，然后在复制时将Q放在坏根的对应位置之后。		②若某数组不能找到与坏根前面部分相同的n级子数组，在它们前面都添加坏根的内容，中间的分隔符等级与坏根的末项等级相同，然后在复制时将Q放在坏根的对应位置之后。
	例如坏部为(2,1)(2,2)(2,1/2)时，将(2,2)改为(2,1/2,2)，(2,1)和(2,1/2)不变。Q=(/2/1)，坏根为(2,1)时，坏部的(2,1/2)一次复制后变为(2,1 /2/1 /2)，坏部的(2,2)变为(2,1 /2/1 /2,2)。		例如坏部为(2,1)(2,2)(2,1/2)时，将(2,2)改为(2,1/2,2)，(2,1)和(2,1/2)不变。Q=(/2/1)，坏根为(2,1)时，坏部的(2,1/2)一次复制后变为(2,1 /2/1 /2)，坏部的(2,2)变为(2,1 /2/1 /2,2)。

	6）坏根寻找方法同3）。定义阶伸项Q为坏根与原末数组相比缺少的部分，坏部B为{原末数组，其中末项-1}，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。		6）坏根寻找方法同3）。定义阶伸项Q为坏根与原末数组相比缺少的部分，坏部B为{原末数组，其中末项-1}，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。

	7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。		7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。

2025年8月19日 (二) 11:38 油手就行

2025-08-19T11:38:09Z

←上一版本		2025年8月19日 (二) 19:38的版本
第1行：		第1行：
	== Tree Sequence System~~(TrSS) designed by Ysjs ver1.1~~ ==		== Tree Sequence System ==
	=== 零．前言 ===		=== 零．前言 ===
	TrSS全称Tree Sequence System，是由树状结构启发而制作的记号。记号的表达式是一个树列，为方便呈现，将树列改写为数组列形式，本文档所述为数组列展开规则，但TrSS本身并不是矩阵。本文档中绿色小字体为注释或举例，红色字体为重要内容。		TrSS全称Tree Sequence System，是由树状结构启发而制作的记号。记号的表达式是一个树列，为方便呈现，将树列改写为数组列形式，本文档所述为数组列展开规则，但TrSS本身并不是矩阵。本文档中绿色小字体为注释或举例，红色字体为重要内容。
	TrSS是由数组作为项组成的序列，每个数组由正整数和分隔符组成。序列的第一个数组必须为(1)。数和分隔符都有等级，对于数n+1，其等级为n。分隔符有ω种，对于i，i级分隔符为i个连续的逗号；特别的，0级分隔符为“/”。数后面的分隔符等级不能高于数的等级，否则不合法。		TrSS是由数组作为项组成的序列，每个数组由正整数和分隔符组成。序列的第一个数组必须为(1)。数和分隔符都有等级，对于数n+1，其等级为n。分隔符有ω种，对于i，i级分隔符为i个连续的逗号；特别的，0级分隔符为“/”。数后面的分隔符等级不能高于数的等级，否则不合法。
	每个合法数组都可以被绘制为树，绘制这样的树有三种操作：①向上一步；②从原地开始向上画k个依次相连的节点；③向右一步。从数组的首项开始，每遇到一个数k就执行②一次，每遇到一个n级分隔符就执行③一次，然后执行① n次。每执行一次①或③，就要在新到达的位置和原来的位置中间画一条边。如果一个分隔符后面的数是0，那么删去0及该分隔符。		每个合法数组都可以被绘制为树，绘制这样的树有三种操作：①向上一步；②从原地开始向上画k个依次相连的节点；③向右一步。从数组的首项开始，每遇到一个数k就执行②一次，每遇到一个n级分隔符就执行③一次，然后执行① n次。每执行一次①或③，就要在新到达的位置和原来的位置中间画一条边。如果一个分隔符后面的数是0，那么删去0及该分隔符。
	数组之间比较字典序时，将其视为(a1 分隔符 a2 分隔符……)(b1 分隔符 b2 分隔符……)的形式依次比较对应的数或分隔符，高等级分隔符>~~低等级分隔符。~~		数组之间比较字典序时，将其视为(a1 分隔符 a2 分隔符……)(b1 分隔符 b2 分隔符……)的形式依次比较对应的数或分隔符，高等级分隔符>低等级分隔符。例如，(2,2,1)>(2,2/1)。
	~~例如，~~(2,2,1)>(2,2/1)
	符号指代范围（重要）：		符号指代范围（重要）：
	i、j、k正整数 m、n 、p自然数 a_i、b_i、c_i数列的第i项 %、#、$、&任意合法表达式/数组 A、B、C 任意分隔符		i、j、k正整数 m、n 、p自然数 a_i、b_i、c_i数列的第i项 %、#、$、&任意合法表达式/数组 A、B、C 任意分隔符
	TrSS的极限表达式为(1)(ω)。		TrSS的极限表达式为(1)(ω)。作为新型记号的首次尝试，此记号可能有不完善之处，请指出并联系我修改。
	~~作为新型记号的首次尝试，此记号可能有不完善之处，请指出并联系我修改。~~
	油手就行		油手就行
	更新日志：		更新日志：
第38行：		第36行：

	2）将末数组的末项和末分隔符中不为0的元素等级-1。		2）将末数组的末项和末分隔符中不为0的元素等级-1。
	Ⅰ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。		Ⅰ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。
	Ⅱ.若末分隔符等级为0或数组仅有一个数而末项等级>0，则将末项等级-1。		Ⅱ.若末分隔符等级为0或数组仅有一个数而末项等级>0，则将末项等级-1。
	Ⅲ.若二者等级均为0，则将二者都删去。		Ⅲ.若二者等级均为0，则将二者都删去。
	Ⅳ.若二者等级均>0，则将末项等级-1，然后寻找数组中最靠后的比末分隔符等级低的分隔符A，在后面添加一个比末分隔符低一级的分隔符以及原数组的(A,倒数第二项]。若找不到这样的分隔符，则视为它在数组最前面并且隐形。		Ⅳ.若二者等级均>0，则将末项等级-1，然后寻找数组中最靠后的比末分隔符等级低的分隔符A，在后面添加一个比末分隔符低一级的分隔符以及原数组的(A,倒数第二项]。若找不到这样的分隔符，则视为它在数组最前面并且隐形。
	Ⅴ.~~若数组中只有一个分隔符且末项等级为0，那么将它们删去。优先级最高~~		Ⅴ.若数组中只有一个分隔符且末项等级为0，那么将它们删去。'''优先级最高'''
	若经过变换的末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么进入3）。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入4）。		若经过变换的末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么进入3）。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入4）。

	(2,1/1)根据Ⅲ变为(2,1)；(2,1/2/2)根据Ⅱ变为(2,1/2/1)，(2,1/2,1)根据Ⅳ变为(2,1/2/2)，(3,,3,1)根据Ⅰ变为(3,,3/3)，(2,2,2)根据Ⅳ变为(2,2,1/2,2)，(2,1)根据Ⅴ变为(2)		例如，(2,1/1)根据Ⅲ变为(2,1)；(2,1/2/2)根据Ⅱ变为(2,1/2/1)，(2,1/2,1)根据Ⅳ变为(2,1/2/2)，(3,,3,1)根据Ⅰ变为(3,,3/3)，(2,2,2)根据Ⅳ变为(2,2,1/2,2)，(2,1)根据Ⅴ变为(2)。

	3）今有若干数组、&的n级子数组#、#、#……#、#$，其中#不为空，且均为类似构造的数组中最靠后的：		3）今有若干数组、&的n级子数组#、#、#……#、#$，其中#不为空，且均为类似构造的数组中最靠后的：
	①若$为空，那么坏根为&_i并进入④。否则进入②。		①若$为空，那么坏根为&_i并进入④。否则进入②。
	②若任意%_j在字典序上都大于等于$，那么坏根为并进入④。否则进入③。		②若任意%_j在字典序上都大于等于$，那么坏根为并进入④。否则进入③。
	③找到最大的j，使得%_j的字典序小于$，坏根为&_j并进入④。		③找到最大的j，使得%_j的字典序小于$，坏根为&_j并进入④。
	④进入5）。		④进入5）。
	4）定义阶伸项Q为{原末数组，其中末项-1}∪{(原末数组的末项-2)级分隔符}，坏部B为[表达式第二个数组，表达式倒数第二个数组]，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。		4）定义阶伸项Q为{原末数组，其中末项-1}∪{(原末数组的末项-2)级分隔符}，坏部B为[表达式第二个数组，表达式倒数第二个数组]，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。
	5）定义坏部B为[坏根，表达式倒数第二个数组]，好部G为[表达式首项，坏根)，阶伸项Q为将(坏根与经过1）或2）操作的末数组相比缺少的部分)还原为数组的结果。		5）定义坏部B为[坏根，表达式倒数第二个数组]，好部G为[表达式首项，坏根)，阶伸项Q为将(坏根与经过1）或2）操作的末数组相比缺少的部分)还原为数组的结果。
	Ⅰ.对于坏部中原本属于3）中提到的&_i中的数组，每次复制时将Q放在坏根的对应位置之后。此时Q的开头一定是分隔符，末尾一定是数。		Ⅰ.对于坏部中原本属于3）中提到的&_i中的数组，每次复制时将Q放在坏根的对应位置之后。此时Q的开头一定是分隔符，末尾一定是数。
	Ⅱ.对于坏部中不是原本属于3）中提到的&_i中的数组：		Ⅱ.对于坏部中不是原本属于3）中提到的&_i中的数组：
	①若某数组可以找到与坏根前面部分相同的n级子数组，那么不对它做任何操作，直接添加阶伸项。		①若某数组可以找到与坏根前面部分相同的n级子数组，那么不对它做任何操作，直接添加阶伸项。
	②若某数组不能找到与坏根前面部分相同的n级子数组，在它们前面都添加坏根的内容，中间的分隔符等级与坏根的末项等级相同，然后在复制时将Q放在坏根的对应位置之后。		②若某数组不能找到与坏根前面部分相同的n级子数组，在它们前面都添加坏根的内容，中间的分隔符等级与坏根的末项等级相同，然后在复制时将Q放在坏根的对应位置之后。
	~~坏部为~~(2,1)(2,2)(2,1/2)，将(2,2)改为(2,1/2,2)，(2,1)和(2,1/2)~~不变。~~		例如坏部为(2,1)(2,2)(2,1/2)时，将(2,2)改为(2,1/2,2)，(2,1)和(2,1/2)不变。Q=(/2/1)，坏根为(2,1)时，坏部的(2,1/2)一次复制后变为(2,1 /2/1 /2)，坏部的(2,2)变为(2,1 /2/1 /2,2)。
	Q=(/2/1)，坏根为(2,1)时，坏部的(2,1/2)一次复制后变为(2,1 /2/1 /2)，坏部的(2,2)变为(2,1 /2/1 /2,2)
	6）坏根寻找方法同3）。定义阶伸项Q为坏根与原末数组相比缺少的部分，坏部B为{原末数组，其中末项-1}，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。		6）坏根寻找方法同3）。定义阶伸项Q为坏根与原末数组相比缺少的部分，坏部B为{原末数组，其中末项-1}，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。
	7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。		7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。

油手就行：创建页面，内容为“== Tree Sequence System(TrSS) designed by Ysjs ver1.1 == === 零．前言 === TrSS全称Tree Sequence System，是由树状结构启发而制作的记号。记号的表达式是一个树列，为方便呈现，将树列改写为数组列形式，本文档所述为数组列展开规则，但TrSS本身并不是矩阵。本文档中绿色小字体为注释或举例，红色字体为重要内容。 TrSS是由数组作为项组成的序列，每个数组由正整数…”

2025-08-19T11:34:04Z

创建页面，内容为“== Tree Sequence System(TrSS) designed by Ysjs ver1.1 == === 零．前言 === TrSS全称Tree Sequence System，是由树状结构启发而制作的记号。记号的表达式是一个树列，为方便呈现，将树列改写为数组列形式，本文档所述为数组列展开规则，但TrSS本身并不是矩阵。本文档中绿色小字体为注释或举例，红色字体为重要内容。 TrSS是由数组作为项组成的序列，每个数组由正整数…”

新页面

== Tree Sequence System(TrSS) designed by Ysjs ver1.1 ==
=== 零．前言 ===
TrSS全称Tree Sequence System，是由树状结构启发而制作的记号。记号的表达式是一个树列，为方便呈现，将树列改写为数组列形式，本文档所述为数组列展开规则，但TrSS本身并不是矩阵。本文档中绿色小字体为注释或举例，红色字体为重要内容。
TrSS是由数组作为项组成的序列，每个数组由正整数和分隔符组成。序列的第一个数组必须为(1)。数和分隔符都有等级，对于数n+1，其等级为n。分隔符有ω种，对于i，i级分隔符为i个连续的逗号；特别的，0级分隔符为“/”。数后面的分隔符等级不能高于数的等级，否则不合法。
每个合法数组都可以被绘制为树，绘制这样的树有三种操作：①向上一步；②从原地开始向上画k个依次相连的节点；③向右一步。从数组的首项开始，每遇到一个数k就执行②一次，每遇到一个n级分隔符就执行③一次，然后执行① n次。每执行一次①或③，就要在新到达的位置和原来的位置中间画一条边。如果一个分隔符后面的数是0，那么删去0及该分隔符。
数组之间比较字典序时，将其视为(a1 分隔符 a2 分隔符……)(b1 分隔符 b2 分隔符……)的形式依次比较对应的数或分隔符，高等级分隔符>低等级分隔符。
例如，(2,2,1)>(2,2/1)
符号指代范围（重要）：
i、j、k正整数 m、n 、p自然数 a_i、b_i、c_i数列的第i项 %、#、$、&任意合法表达式/数组 A、B、C 任意分隔符
TrSS的极限表达式为(1)(ω)。
作为新型记号的首次尝试，此记号可能有不完善之处，请指出并联系我修改。
油手就行
更新日志：
2025.8.18 TrSS v1.0
TrSS正式被定义。
2025.8.19 TrSS v1.1
修改了寻找坏根的方法。
=== 一．前置定义 ===
1.子数组：
1）一个数组的-1级子数组是它本身。
2）从m=0开始，将每个数组的每个(m-1)级子数组按其中的m级分隔符分开，分开后的部分称为原数组的m级子数组。如果数组的m级子数组内仍有分隔符，那么进入3）；如果数组的m级子数组内没有分隔符，那么流程结束。（展开时用到的子数组不一定是最高等级的）
3）使m的值+1，然后回到2）
(2,1/2/1)的0级子数组为(2,1)(/2)(/1)，1级子数组为(2)(,1)(/2)(/1)
2.元素：数组(的子数组)的元素是其中的所有数和分隔符。
3.末数组：表达式中最后一个数组。
4.末项/分隔符：数组中最后一个数/分隔符。
=== 二．展开流程 ===
1.#(1)=#+1
2.在末数组不为(1)时：
1）从n=(表达式中出现的最高等级分隔符的等级)开始，取每个数组的n级子数组。
①若末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么使末数组的末项等级-1，此时：
Ⅰ.若末项和末分隔符等级都为0，则将二者都删去。
Ⅱ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。
然后进入6），否则进入②。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入2）。
②使n的值-1并回到①。
(2,1/2)和(2,1/2)的-1级子数组相同，和(2,1/2/2)的0级子数组部分相同
# 有序列表项

2）将末数组的末项和末分隔符中不为0的元素等级-1。
Ⅰ.若末分隔符等级>0而末项等级为0，则将分隔符等级-1，然后将末项的值改为与倒数第二项相同的值。
Ⅱ.若末分隔符等级为0或数组仅有一个数而末项等级>0，则将末项等级-1。
Ⅲ.若二者等级均为0，则将二者都删去。
Ⅳ.若二者等级均>0，则将末项等级-1，然后寻找数组中最靠后的比末分隔符等级低的分隔符A，在后面添加一个比末分隔符低一级的分隔符以及原数组的(A,倒数第二项]。若找不到这样的分隔符，则视为它在数组最前面并且隐形。
Ⅴ.若数组中只有一个分隔符且末项等级为0，那么将它们删去。优先级最高
若经过变换的末数组的n级子数组在后面去掉连续的部分后与前面某数组的n级子数组在数和分隔符上都相同，那么进入3）。如果直到n=-1都没能找到前面部分与末数组相同的数组，那么进入4）。

(2,1/1)根据Ⅲ变为(2,1)；(2,1/2/2)根据Ⅱ变为(2,1/2/1)，(2,1/2,1)根据Ⅳ变为(2,1/2/2)，(3,,3,1)根据Ⅰ变为(3,,3/3)，(2,2,2)根据Ⅳ变为(2,2,1/2,2)，(2,1)根据Ⅴ变为(2)

3）今有若干数组、&的n级子数组#、#、#……#、#$，其中#不为空，且均为类似构造的数组中最靠后的：
①若$为空，那么坏根为&_i并进入④。否则进入②。
②若任意%_j在字典序上都大于等于$，那么坏根为并进入④。否则进入③。
③找到最大的j，使得%_j的字典序小于$，坏根为&_j并进入④。
④进入5）。
4）定义阶伸项Q为{原末数组，其中末项-1}∪{(原末数组的末项-2)级分隔符}，坏部B为[表达式第二个数组，表达式倒数第二个数组]，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。
5）定义坏部B为[坏根，表达式倒数第二个数组]，好部G为[表达式首项，坏根)，阶伸项Q为将(坏根与经过1）或2）操作的末数组相比缺少的部分)还原为数组的结果。
Ⅰ.对于坏部中原本属于3）中提到的&_i中的数组，每次复制时将Q放在坏根的对应位置之后。此时Q的开头一定是分隔符，末尾一定是数。
Ⅱ.对于坏部中不是原本属于3）中提到的&_i中的数组：
①若某数组可以找到与坏根前面部分相同的n级子数组，那么不对它做任何操作，直接添加阶伸项。
②若某数组不能找到与坏根前面部分相同的n级子数组，在它们前面都添加坏根的内容，中间的分隔符等级与坏根的末项等级相同，然后在复制时将Q放在坏根的对应位置之后。
坏部为(2,1)(2,2)(2,1/2)，将(2,2)改为(2,1/2,2)，(2,1)和(2,1/2)不变。
Q=(/2/1)，坏根为(2,1)时，坏部的(2,1/2)一次复制后变为(2,1 /2/1 /2)，坏部的(2,2)变为(2,1 /2/1 /2,2)
6）坏根寻找方法同3）。定义阶伸项Q为坏根与原末数组相比缺少的部分，坏部B为{原末数组，其中末项-1}，好部G为首数组(1)，展开为G+B+QB+QQB+QQQB……其中QB指在B中的每个数组前都添加一个Q。
7）无论通过4）、5）还是6）展开的表达式，都要保证每个数组的第一个分隔符等级不为0。如果为0，那么将其改为1级分隔符。