计算群论基础算法：Schreier-Sims 算法

Schreier-Sims 算法是一种寻找置换群的强生成元（SGS）的有效算法，它在计算群论中非常有用，如果找到一组 SGS，可以很容易判断任意置换是否在置换群中，如果在群中，还可以求出该置换具体如何由生成元表示。

本人了解这个算法的动机是听说它可以用来破解魔方……众所周知，普通的三阶魔方有 48 个贴纸（中心块不算），因此魔方的任意操作都可以看做对 48 个贴纸做置换，从而魔方的操作构成了对称群 $S_{48}$ 的子群，其生成元就是六个面各自顺时针旋转 90 度的操作（称为基本操作），将任意置换表示成基本操作的复合就算是解了魔方。因此使用 Schreier-Sims 算法来解魔方可以说是小菜一碟，并且可以解任意可以用群来描述的魔方。（然而一些带有捆绑特性的魔方不容易用群描述，因为两次合法旋转的复合未必就合法。这就超出本文的范围了。）

群论前置知识

阅读本文前需要先了解群论的一些最基本的概念：群（子群，生成子群，正规子群），置换群（对称群，交错群），同态，群作用，轨道和稳定子。详细的讲解可以在很多抽象代数教材中找到，在此不多赘述。

群作用一般有两种不同的记法，本文采用的是右作用的记法：群 $G$ 在集合 $\Omega$ 上的作用记为$$(\alpha ,g)\mapsto {\alpha }^g,$$其中 $\alpha \in \Omega ,g\in G$。群作用需要满足的两个条件写为$${\alpha }^1=\alpha ,({\alpha }^g{)}^h={\alpha }^{gh}(\forall \alpha \in \Omega ,g,h\in G).$$其中 $1$ 是群 $G$ 的单位元，以后乘法群的单位元一律记作 $1$，仅含一个单位元的群（平凡群）也记作 $1$。特别需要注意的是第二个等式，群作用的复合是先算左边再算右边，与通常的函数复合（$(g\circ f)(x)=g(f(x))$）顺序恰好相反。

群 $G$ 在集合 $\Omega$ 上的作用与形如 $G\to \mathrm{Sym}(\Omega )$ 的同态是对应的（其中 $\mathrm{Sym}(\Omega )$ 是 $\Omega$ 的对称群）。特别地，如果 $G\le \mathrm{Sym}(\Omega )$ 本身就是 $\Omega$ 的置换群，则自然有 $G\to \mathrm{Sym}(\Omega )$ 的同态映射（该映射简单地把 $G$ 中任意元素映到自身），它对应群 $G$ 在集合 $\Omega$ 上的自然作用，并且该作用是忠实的（即：$G$ 中唯一一个将 $\Omega$ 中所有元素映射到自身的元素是单位元 $1$），因为对应的同态是单同态。因此以后凡是假设 $G$ 是 $\mathrm{Sym}(\Omega )$ 的子群，同时也就等同于默认 $G$ 是 $\Omega$ 上的忠实作用。

置换的复合也是先算左边再算右边。例如取$$\alpha =1,g=(12),h=(13),$$则有$${\alpha }^{gh}=({\alpha }^g{)}^h=(1^g{)}^h=2^h=2.$$再取 $\alpha =2,3$ 计算可知 $gh=(123)$。置换复合的顺序不可随意颠倒，例如此处若遵守先右后左的规定，$(12)(13)$ 的结果就是 $(132)$ 了。

预备知识：Transversal

本文需要用到的唯一一个有必要在此说明的概念是 transversal，中文直译类似于“断面”“截面”。设 $H$ 是群 $G$ 的子群，考虑 $H$ 的右陪集空间$$\{Hg:g\in G\},$$从每个陪集中任取一个元素（代表元），这些元素组成的集合就是 transversal。如果把每个陪集看做是一张纸，则所有陪集的并集 $G$ 就是一摞叠起来的纸，而 transversal 相当于纵向切开这一摞纸得到的截面，这个截面是由每张纸上取一条线组成的。

设 $H\le G$ 有 transversal $R$，通常规定从陪集 $H1=H$ 中取出的代表元是单位元 $1$，即 $1\in R$。$g\in G$ 所在陪集的代表元通常记为 $\overline{g}$，即$$\overline{g}=Hg\cap R.$$

预备知识：群在计算机中的表示

表示一个群有很多种方法，其中最直观的就是乘法表。然而我们研究的群通常阶数都很大，少量的生成元就可以生成阶数巨大的群，例如三阶魔方的可行状态数有$$(2^{12}\cdot 12!\cdot 3^8\cdot 8!)/(2\cdot 2\cdot 3)=43,252,003,274,489,856,000$$种，这也是三阶魔方通过旋转得到的置换群的阶数，而这个置换群至多用 6 个元素（即 6 种基本操作）就可以生成了。显然，不可能在计算机中存储如此巨大的乘法表，即使仅仅存储或者遍历群中所有元素（因为置换的复合很容易计算，无需存储运算的结果）都不可能。

一般来说，群的表示可以分为三种情况，这些情况是关于我们可以对群中元素做什么操作的描述。
情况 A：群中的任意元素都可以在计算机中表示（一般是用某种数据结构表示），并且可以计算任意两个元素的乘积和任意元素的逆元。但无法判断两个元素是否相等。例如由群表示 $⟨X|R⟩$ 描述的群。
情况 B：群中的任意元素都可以在计算机中表示，可以计算任意两个元素的乘积和任意元素的逆元，也可以判断两个元素是否相等。例如由若干个置换生成的置换群，置换的复合、逆元以及判断相等都是很容易的。
情况 C：在满足情况 B 的同时，还知道该群有一组特殊的生成元 $g_1,\cdots ,g_r$，并且有一个通用的算法可以将群中任意元素分解成 $g_1,\cdots ,g_r$ 的某些元素和/或逆元（这些元素不必不同）相乘的形式。

本文仅考虑置换群的情况，通常我们需要处理的是置换群 $G=⟨X⟩\le \mathrm{Sym}(\Omega )$，其中 $X$ 是已知的生成元集合，在计算机中表示为置换的列表，作为程序的输入。（本文中 $\Omega$ 总是有限集，并且通常就用整数 $1$ 到 $n$ 表示。）于是如同之前所说，此时我们处在情况 B。而 Schreier-Sims 算法可以找到一组满足情况 C 的生成元（称为强生成元，SGS），从而到达情况 C。一旦到达情况 C，很多关于置换群的算法就有了用武之地。
以后当我们说“已知置换群 $G=⟨X⟩$” 时，实际上程序真正的输入是生成元的列表 $X$，不再逐一解释。

预备算法：计算置换群的轨道和稳定子

首先需要解决的问题是：给定置换群 $G=⟨X⟩\le \mathrm{Sym}(\Omega )$ 和 $\alpha \in \Omega$，计算 $\alpha$ 的轨道 ${\alpha }^G$ 和稳定子 $G_{\alpha }$。当然，我们不可能输出 $G_{\alpha }$ 的每个元素，只要求输出一组生成元即可。这是计算群论中少数几个不用强生成元就可以有效解决的问题之一。

轨道

先考虑如何计算轨道。当然，我们不可能直接用定义 ${\alpha }^G=\{{\alpha }^g:g\in G\}$ 计算，因为遍历群 $G$ 所有元素的时间复杂度无法接受。注意到任意 $g\in G$ 都可以表示成 $g=x_1{x}_2\cdots x_r$ 的形式（其中每个 $x_i$ 都是 $X$ 的元素；之所以不考虑 $X$ 中元素的逆元，是因为有限群的元素总是有限阶，故 $x_i^{-1}$ 总等于 $x_i^{|x_i|-1}$），因此形如 ${\alpha }^g$ 的元素都可以表示成 $(({\alpha }^{x_1}{)}^{\cdots }{)}^{x_r}$ 的形式。自然，可以用图的遍历解决求轨道的问题：

以 $\Omega$ 中元素为顶点构造有向图，若元素 $\beta ,\gamma \in \Omega$ 满足存在 $x\in X$ 使得 ${\beta }^x=\gamma$，则连一条从 $\beta$ 到 $\gamma$ 的有向边。从 $\alpha$ 出发能够到达的所有顶点（包括 $\alpha$ 自身）就是轨道 ${\alpha }^G$。

事实上不需显式建图也可以完成遍历过程。下面是 Python 风格的伪代码。

def orbit(alpha, X):
	## Calculate alpha^G where G=.
	Delta = [alpha]
	for beta in Delta:
		for x in X:
			if beta^x not in Delta:
				Delta.append(beta^x)
	return Delta

此处变量的命名为了区分大小写，稍微违反了一下命名规范；另外外层 for 循环的 Delta 会在循环内部改变，这种写法是不推荐的，这里只是为了简洁使用这种写法。运算符 ^ 表示群作用，变量 Delta（即 $\Delta$）表示已经搜索到的元素的集合，程序终止时 $\Delta$ 就是所求的轨道。

通常应用该算法时不仅需要求出 $\alpha$ 的轨道 ${\alpha }^G$，同时需要对每个 $\beta \in {\alpha }^G$ 赋予一个代表元 $u_{\beta }$，使得 ${\alpha }^{u_{\beta }}=\beta$。事实上，因为满足 ${\alpha }^g=\beta$ 的所有 $g\in G$ 组成的集合就是稳定子 $G_{\alpha }$ 的右陪集，我们立刻可知代表元集$$\{u_{\beta }:\beta \in {\alpha }^G\}$$就是 $G_{\alpha }$ 的一个 transversal。计算代表元也不难，只需在遍历搜索的时候记录轨道中每个元素对应的代表元。若当前已知 $\beta \in \Delta$，继续向下搜索发现 ${\beta }^x=\gamma \notin \Delta$，则令 $u_{\gamma }=u_{\beta }x$ 即可，因为$${\alpha }^{u_{\gamma }}={\alpha }^{u_{\beta }x}={\beta }^x=\gamma .$$修改后的算法如下。

def orbit_u(alpha, X):
	## Calculate alpha^G and a transversal of G_alpha where G=.
	Delta = [(alpha, 1)]
	for beta, u_beta in Delta:
		for x in X:
			if beta^x not in [b for b,_ in Delta]:
				Delta.append((beta^x, u_beta*x))
	return Delta

该算法可以进一步优化，例如显然判断 ${\beta }^x\in \Delta$ 的操作比较浪费时间，至于具体如何优化，后面再讲，这里只是先给出一个大体的框架。

稳定子

现在考虑如何计算稳定子，当然如之前所说，我们只要找到 $G_{\alpha }$ 的一组生成元就算完成任务。为此需要一个引理。

（Schreier 引理）设子群 $H\le G=⟨X⟩$ 有 transversal $R$，满足 $1\in R$，则$$Y=\{rx(\overline{rx}{)}^{-1}:r\in R,x\in X\}$$ 是 $H$ 的一组生成元。（$Y$ 称为 Schreier 生成元。）
证明：首先由 $Hrx=H\overline{rx}$ 可知 $rs(\overline{rx}{)}^{-1}\in H$，从而只需证明 $H$ 中任意元素都可以表示为若干形如 $rx(\overline{rx}{)}^{-1}$ 的元素的乘积。任取 $h=x_1^{\pm }{x}_2^{\pm }\cdots x_k^{\pm }$（其中 $x_i\in X$，上角标 $\pm$ 表示可正可负，$x^{+},x^{-}$ 分别表示 $x,x^{-1}$），令$$r_i=\overline{x_1^{\pm }{x}_2^{\pm }\cdots x_i^{\pm }}(i=1,\cdots ,k),r_0=1,$$则有$$h=(r_0{x}_1^{\pm }{r}_1^{-1})(r_1{x}_2^{\pm }{r}_2^{-1})\cdots (r_{k-1}{x}_k^{\pm }{r}_k^{-1}).$$注意到$$H{r}_i=H{x}_1^{\pm }{x}_2^{\pm }\cdots x_i^{\pm }=H{r}_{i-1}{x}_i^{\pm },H{r}_i\in R,$$即 $r_i=\overline{r_{i-1}{x}_i^{\pm }}$，这说明上面的 $h$ 的分拆中所有带正号的项都是 $T$ 的元素。带负号的项可以变为$$r_{i-1}{x}_i^{-1}{r}_i^{-1}=(r_i{x}_i{r}_{i-1}^{-1}{)}^{-1},$$
而由 $H{r}_i{x}_i=H(x_1^{\pm }{x}_2^{\pm }\cdots x_{i-1}^{\pm }{x}_i^{-1})x_i=H{x}_1^{\pm }{x}_2^{\pm }\cdots x_{i-1}^{\pm }=H{r}_{i-1}$ 可知 $r_{i-1}=\overline{r_i{x}_i}$，因此 $r_{i-1}{x}_i^{-1}{r}_i^{-1}$ 是 $T$ 的某个元素的逆元。至此就证明了 $h$ 可以由 $Y$ 中的元素生成。

特别地，在引理中取 $H=G_{\alpha }$，则 $r\in R$ 可以替换成 $u_{\beta }(\beta \in {\alpha }^G)$，同时注意到 $G_{\alpha }(u_{\beta }x)$ 将 $\alpha$ 映射到 ${\beta }^x$，可知 $\overline{u_{\beta }x}=u_{{\beta }^x}$，从而得到 Schreier 引理的轨道-稳定子版本：

（Schreier 引理）设群 $G=⟨X⟩$ 是 $\Omega$ 上的置换群，$\alpha \in \Omega$，对任意 $\beta \in {\alpha }^G$ 有一代表元 $u_{\beta }$ 满足 ${\alpha }^{u_{\beta }}=\beta$，并且 $u_{\alpha }=1$，则$$Y=\{u_{\beta }x{u}_{{\beta }^x}^{-1}:\beta \in {\alpha }^G,x\in X\}$$ 是 $G_{\alpha }$ 的一组生成元。

利用上述引理可以在计算轨道和 transversal 的同时计算稳定子的生成元。

def orbit_stabilizer(alpha, X):
	## Calculate alpha^G and a transversal of G_alpha where G=,
	## and a generator set Y of =G_alpha.
	Delta = [(alpha, 1)]
	Y = []
	for beta, u_beta in Delta:
		for x in X:
			if beta^x not in [b for b,_ in Delta]:
				Delta.append((beta^x, u_beta*x))
			Y.append((u_beta)*x*(u_(beta^x))')
	return Delta,Y

伪代码中 $x^{\prime }$ 表示 $x$ 的逆元。上述代码很明显可以改进：如果 if 条件判断结果为真，则 $u_{{\beta }^x}=u_{\beta }x$，此时 $u_{\beta }x{u}_{{\beta }^x}^{-1}=1$，不需要把它添入 $Y$ 中，修改后的伪代码如下：

def orbit_stabilizer(alpha, X):
	## Calculate alpha^G and a transversal of G_alpha where G=,
	## and a generator set Y of =G_alpha.
	Delta = [(alpha, 1)]
	Y = []
	for beta, u_beta in Delta:
		for x in X:
			if beta^x not in [b for b,_ in Delta]:
				Delta.append((beta^x, u_beta*x))
			else:
				Y.append((u_beta)*x*(u_(beta^x))')
	return Delta,Y

Schreier 向量

假如判断 ${\beta }^x$ 是否属于 $\Delta$ 的操作可以在常数时间内完成（当然，如果判断结果为真，则顺便可以找到相应的 $u_{{\beta }^x}$），则 orbit_u 的伪代码的时间复杂度应为 $O(|X|n^2)$（准确地说是 $O(|X||\Delta |n)$），其中 $n=|\Omega |$。这是因为循环次数是 $O(|X||\Delta |)$ 的，而每次循环都需要计算置换的复合，用时为 $O(n)$。（当然如果只求轨道不求 $u_{\beta }$，就无需计算置换的复合，时间复杂度为 $O(|X||\Delta |)$。）

是否可以在常数时间内完成判断操作？当然可以。不妨设 $\Omega =\{1,\cdots ,n\}$，只要开一个长度为 $n$ 的数组 $A$，若 $\beta \in \Delta$，则 $A[\beta ]=u_{\beta }$，否则 $A[\beta ]$ 为空对象。初始时将数组中所有元素置空，仅将 $A[\alpha ]$ 设置为恒等置换即可。时间复杂度 $O(|X|n^2)$，空间复杂度 $O(n^2)$。

如果需要节省空间，可以改用平衡树等数据结构维护 $\Delta$ 列表，但这样只是把空间复杂度改进为 $O(|\Delta |n)$，如果 $\Delta =\Omega$（或者 $\Delta$ 比 $n$ 小不了多少），这种改进就有点废了。实际上，我们未必要对所有 $\beta \in \Delta$ 都存储 $u_{\beta }$，那样太浪费空间了；我们用类似于记录前驱的方式存储必要的信息，需要算 $u_{\beta }$ 时可以临时再算。

对于 $\alpha ̸=\gamma \in \Delta$，根据上述算法可知存在 $\beta \in \Delta ,x\in X$ 使得 $\gamma ={\beta }^x,u_{\gamma }=u_{\beta }x$，因此对任意 $\gamma$ 只要存储与之相关的 $\beta ,x$ 即可。事实上只需存储 $x$，$\beta$ 可由 $\beta ={\gamma }^{x^{-1}}$ 计算；而我们不需要存储 $x$ 的真实值，只需存储 $x$ 是 $X$ 中第几个元素即可。也就是说，我们需要存储一个向量 $v[1..n]$，满足：

$v[\alpha ]=-1$；
若 $\gamma$ 是通过 ${\beta }^{x_i}$ 添加进 $\Delta$ 的（其中 $\beta ,\gamma \in \Delta$），则说明 $u_{\gamma }=u_{\beta }{x}_i$（$x_i$ 是列表 $X$ 的第 $i$ 个元素，从 1 开始计数），记 $v[\gamma ]=i$；
若 $\beta \notin \Delta$，则记 $v[\beta ]=0$。

该向量称为 Schreier 向量，它可以同时完成“判断 ${\beta }^x$ 是否属于 $\Delta$”和“存储 $u_{\beta }$”的操作。对应的伪代码如下：

def orbit_sv(alpha, X):
	## Calculate alpha^G and a transversal of G_alpha where G=.
	## Assuming Omega = [1..n].
	r = len(X)
	v = [0] * (n+1)
	v[alpha]=-1
	Delta = [alpha]
	for beta in Delta:
		for i in range(1, r+1):
			if v[beta^(X[i])] == 0:
				Delta.append(beta^(X[i]))
				v[beta^(X[i])] = i
	return Delta, v

该算法的时间复杂度为 $O(|X||\Delta |)$，空间复杂度为 $O(n)$，可以说是相当不错。当然这也不是毫无代价的：计算 $u_{\beta }$ 有额外的时间开销。计算 $u_{\beta }$ 的算法实际上就是沿向量 $v$ 提供的数值一路倒推，直到倒推到 $\alpha$，具体如下所示。

def u_beta(beta, v, X):
	## Calculate u_beta.
	## Input v is a Schreier vector for alpha in Omega.
	if v[beta] == 0:
		return None
	u = 1
	k = v[beta]
	while k != -1:
		u = X[k]*u
		beta = beta^(X[k]')
		k = v[beta]
	return u

关于时间复杂度，需要提醒的是计算 ${\beta }^{x_k^{-1}}$ 所需时间是常数（这与置换的存储方式有关，对于置换 $g$，如果同时存储 ${\beta }^g,{\beta }^{g^{-1}}(\beta \in \Omega )$，就能在常数时间内算出 ${\beta }^{x_k^{-1}}$）。在这里这件事无所谓了，因为计算 $u\leftarrow x_{k}u$ 的时间是 $O(n)$。算法整体的复杂度最坏情况下可能达到 $O(n^2)$，例如 $X$ 仅有一个元素 $(123\cdots n)$，而 $\alpha =1,\beta =n$，此时需要倒推 $n-1$ 步。显然这与 Schreier 树（就是刚才进行搜索得到的搜索树）的深度有关，深度最坏情况下可以达到 $O(n)$，这样时间复杂度就比较糟糕，而如果 $X$ 不只有一个元素，哪怕只有两个元素，树的深度也可能大幅降低。

至于如何计算稳定子，实际上我们不一定要立刻把 Schreier 生成元一次算出来，那样也会浪费空间。后面会看到，我们需要遍历所有 Schreier 生成元，用来判断稳定子 $G_{\alpha }$ 是否是另一个群的子群。回顾 Schreier 生成元的定义 $Y=\{u_{\beta }x{u}_{{\beta }^x}^{-1}:\beta \in {\alpha }^G,x\in X\}$，显然我们随时可以通过遍历 $\beta \in {\alpha }^G,x\in X$ 来遍历所有 Schreier 生成元，不用先算出所有生成元存起来。

基（Base）& 强生成元（SGS）

基本定义

本节继续假设 $G\le \mathrm{Sym}(\Omega ),\Omega =\{1,\cdots ,n\}.$

设 $B=({\beta }_1,\cdots ,{\beta }_m)$ 是 $\Omega$ 中某些互不相同的元素组成的序列，若群 $G$ 中唯一固定所有 ${\beta }_i(1\le i\le m)$ 的置换是恒等置换，则称 $B$ 是 $G$ 的一组基（base）。该定义可以用逐点稳定子的概念重新叙述：记 $G_{({\beta }_1,\cdots ,{\beta }_m)}=\{g\in G:{\beta }_i^g={\beta }_i(1\le i\le m)\}$ 为 $G$ 关于 $({\beta }_1,\cdots ,{\beta }_m)$ 的逐点稳定子，则 $B$ 是 $G$ 的一组基当且仅当 $G_{({\beta }_1,\cdots ,{\beta }_m)}=1$。

接下来，我们定义$$G^{[i]}=G_{({\beta }_1,\cdots ,{\beta }_i-1)}=\{g\in G:{\beta }_j^g={\beta }_j(1\le j<i)\},$$特别地，定义 $G^{[1]}=G$，则该定义实际上给出了一条子群链：$$G=G^{[1]}\ge G^{[2]}\ge \cdots \ge G^{[m]}\ge G^{[m+1]}=1.$$如果链中每相邻两个群都不相等，则称这组基 $({\beta }_1,\cdots ,{\beta }_m)$ 是无赘余（nonredundant）的。同一个群可以有长度不同的无赘余基，例如取 $G=⟨(12)(3456)⟩\le S_6$，则 $(1,3)$ 和 $(3)$ 都是无赘余基。

链中相邻两项 $G^{[i]}$ 和 $G^{[i+1]}$ 的唯一区别是后者的置换必须固定 ${\beta }_i$，前者不需要，容易看出 $G^{[i+1]}$ 实际上就等于 $G_{{\beta }_i}^{[i]}$。通过计算阶数可得
$$|G|=\prod _{i=1}^m|G^{[i]}:G^{[i+1]}|=\prod _{i=1}^m|{\beta }_i^{G^{[i]}}|,$$因此可以估计链的长度：$2^{|B|}\le |G|\le n^{|B|}$（当然前提是这组基无赘余），即链的长度不会超过 $\log |G|$。当 $|G|$ 大到接近 $|\mathrm{Sym}(\Omega )|=n!$ 时，这个结论没什么用，因为 $O(\log (n!))=n\log n$，而显然 $|B|\le n$。但如果 $|G|$ 比较小，这个结论就有用了。

设 $S$ 是 $G$ 的生成元集，若 $S$ 满足更强的条件：$$⟨S\cap G^{[i]}⟩=G^{[i]}(1\le i\le m+1),$$（需要提醒的是 $⟨\varnothing ⟩=1.$）则称 $S$ 为群 $G$ 关于基 $B$ 的强生成元集（SGS）。
初次接触该定义可能会一脸懵逼，其实并不难理解：$⟨S\cap G^{[i]}⟩=G^{[i]}$ 大体上意思就是“使用生成元集 $S$ 中的元素，不需要移动元素 ${\beta }_1,\cdots ,{\beta }_{i-1}$ 就可以自由排列其他的元素”。不妨考虑魔方群的情况，假设 $S=\{\text{U},\text{D},\text{L},\text{R},\text{F},\text{B}\}$ 是 6 种基本操作的集合，${\beta }_1,\cdots ,{\beta }_{28}$ 是下两层的所有非中心块贴纸。熟悉魔方的都知道不动前两层不可能还原第三层（除非运气好），因此不符合 SGS 的定义。具体地说，就是 $⟨S\cap G^{[29]}⟩=⟨\text{U}⟩̸=G^{[29]}$。
另外再举一个简单的置换群例子：取 $G=S_4$ 为 4 阶对称群，$B=(1,2,3)$ 是一组基，则 $S=\{(1234),(34)\}$ 是 $G$ 的一组生成元，但不是 SGS，因为 $⟨S\cap G^{[2]}⟩̸=G^{[2]}$。这是因为在固定元素 $1$ 不动的前提下 $S$ 中允许的置换只有 $(34)$，仅用该置换不能对元素 $2,3,4$ 自由置换。可以验证 $S^{\prime }=\{(1234),(234),(34)\}$ 是一组 SGS。

筛选过程

假设我们已经有了一组基和对应的一组 SGS，定义 ${\Delta }_i={\beta }_i^{G^{[i]}}$，稳定子 $G_{{\beta }_i}^{[i]}$ 对应的 transversal 为 $R_i$。通过 orbit_sv 和 u_beta 可以算出 ${\Delta }_i$ 和 $R_i$。现在对任意 $g\in G$，我们可以将 $g$ 分解为如下形式：$$g=r_m{r}_{m-1}\cdots r_1(r_i\in R_i,1\le i\le m).$$分解方法是逐步进行的：注意 $G=G^{[1]}$。记 $g_1=g$，首先取$$r_1=u_{{\beta }_1^{g_1}},$$
此时有 ${\beta }_1^{r_1}={\beta }_1^{g_1}$，这说明 $g_1{r}_1^{-1}\in G_{{\beta }_1}^{[1]}=G^{[2]}$，将它记为 $g_2$。然后再取$$r_2=u_{{\beta }_2^{g_2}},$$此时有 ${\beta }_2^{r_2}={\beta }_2^{g_2}$，这说明 $g_2{r}_2^{-1}\in G_{{\beta }_2}^{[2]}=G^{[3]}$，将它记为 $g_3$。该过程可以循环进行，直到得到 $g_{m+1}\in G^{[m+1]}=1$。此时就有$$g=g_1=g_2{r}_1=g_3{r}_2{r}_1=\cdots =g_{m+1}{r}_m\cdots r_1=r_m\cdots r_1.$$实际上，该算法可以用于 $S_n$ 中的任意元素，只不过对 $g\notin G$ 执行该算法会在中途终止。一种情况是计算过程中某个 $g_i$ 不满足 ${\beta }_i^{g_i}\in {\beta }_1^{G^{[i]}}$，这样分解过程只能终止。另一种情况是 $g_{m+1}̸=1$，这说明 $G^{[m+1]}̸=1$，即 $({\beta }_1,\cdots ,{\beta }_m)$ 并不是一组基。该算法称为筛选（sift）过程，该过程要么判断 $g\in G$ 并给出一组分解 $g=r_m{r}_{m-1}\cdots r_1$，要么判断 $g\notin G$ 并返回最终得到的那个 $g_i$ 以及 $i$ 值，这两个返回值都是有用的——它可以用来填补未完成的 SGS 的漏洞，以得到合乎要求的 SGS。返回值 $g_i$ 称为 siftee，似乎可以翻译为筛渣。

Schreier-Sims 算法

下面的引理与 Schreier-Sims 算法有关。

引理 设 $G\le \mathrm{Sym}(\Omega )$，$({\beta }_1,\cdots ,{\beta }_k)$ 是 $\Omega$ 中某些互不相同的元素组成的序列。对 $1\le j\le k+1$，设 $S_j$ 是 $G^{[j]}=G_{({\beta }_1,\cdots ,{\beta }_{j-1})}$ 的子集，满足 $⟨S_j⟩\ge ⟨S_{j+1}⟩(1\le j\le k)$，且 $⟨S_1⟩=G,S_{k+1}=\varnothing$。如果条件$$⟨S_j{⟩}_{{\beta }_j}=⟨S_{j+1}⟩$$（该条件称为条件 *）对任意 $1\le j\le k$ 都成立，则 $B=({\beta }_1,\cdots ,{\beta }_k)$ 是 $G$ 的一组基，$S={\bigcup }_{j=1}^k{S}_j$ 是 $G$ 关于 $B$ 的一组 SGS。
注：条件 * 等价于 $⟨S_j{⟩}_{{\beta }_j}\le ⟨S_{j+1}⟩$，这是因为 $⟨S_j{⟩}_{{\beta }_j}\ge ⟨S_{j+1}⟩$ 总成立：$⟨S_{j+1}⟩$ 的所有元素都属于 $⟨S_j⟩$，且都固定 ${\beta }_j$ 不动。
证明：对 $k$ 使用归纳法。$k=1$ 时条件变为 $⟨S_1{⟩}_{{\beta }_1}=G_{{\beta }_1}=⟨S_{j+1}⟩=⟨\varnothing ⟩=1$，容易验证命题是成立的。
现在假设该命题对更小的 $k$ 成立，于是立刻可得 $B^{\ast }=({\beta }_2,\cdots ,{\beta }_k)$ 是 $G^{\ast }=⟨S_2⟩$ 的基，$S^{\ast }={\bigcup }_{j=2}^k{S}_j$ 是 $G^{\ast }$ 关于 $B^{\ast }$ 的一组 SGS。下面验证 $⟨S\cap G^{[i]}⟩=G^{[i]}$ 对 $1\le i\le m$ 均成立。
$i=1$ 时该条件显然是成立的，因为 $⟨S\cap G⟩=⟨S⟩\ge ⟨S_1⟩=G$。
$i=2$ 时需要验证 $⟨S\cap G^{[2]}⟩=⟨G^{[2]}⟩$，这可由 $G_{{\beta }_1}=⟨S_1{⟩}_{{\beta }_1}=⟨S_2⟩\le ⟨S\cap G_{{\beta }_1}⟩$ 得到（反向不等号是显然的）。
$i>2$ 时需要用到归纳假设，已知 $S^{\ast }$ 是 $G^{\ast }$ 关于 $B^{\ast }$ 的一组 SGS，说明$$⟨S^{\ast }\cap ⟨S_2{⟩}_{({\beta }_2,\cdots ,{\beta }_{i-1})}⟩=⟨S_2{⟩}_{({\beta }_2,\cdots ,{\beta }_{i-1})},$$从而有$$⟨S\cap G_{({\beta }_2,\cdots ,{\beta }_{i-1})}⟩\ge ⟨S^{\ast }\cap ⟨S_2{⟩}_{({\beta }_2,\cdots ,{\beta }_{i-1})}⟩=⟨S_2{⟩}_{({\beta }_2,\cdots ,{\beta }_{i-1})}=(G_{{\beta }_1}{)}_{({\beta }_2,\cdots ,{\beta }_{i-1})}=G^{[i]}.$$同样，反向不等号是显然的。

实际上条件 $⟨S_j{⟩}_{{\beta }_j}=⟨S_{j+1}⟩$ 的意思就是“使用 $S_{j+1}$ 中的元素自由组合，不需要移动元素 ${\beta }_j$ 就可以组合出 $S_j$ 中元素的任意组合”。
Schreier-Sims 算法的输入是 $G=⟨X⟩$，输出是 $G$ 的一组无赘余基 $B$，以及相关的 SGS $S$。算法执行过程中需要维护以下对象：

• 维护变量 $m$，表示当前 $B$ 的长度。
• 维护一组序列 $B=({\beta }_1,\cdots ,{\beta }_m)$，保证 $B$ 是无赘余的，即 $G^{[i]}>G^{[i+1]}(1\le i\le m)$，事实上该算法保证 $G^{[i]}(1\le i\le m)$ 必有一个移动 ${\beta }_i$ 的元素；（不保证 $B$ 是基，也就是说 $G^{[m+1]}$ 未必是平凡群 $1$）
• 维护一组集合 $(S_1,\cdots ,S_m)$，满足 $S_i\subseteq G^{[i]},⟨S_i⟩\ge ⟨S_{i+1}⟩(1\le i\le m)$，这里默认 $S_{m+1}=\varnothing$；
• 维护一个变量 $j$，满足 $0\le j\le m$，并且保证对任意 $i\in (j,m]$ 都满足条件 *，即 $⟨S_i{⟩}_{{\beta }_i}=⟨S_{i+1}⟩(j<i\le m)$。换句话说，$j$ 后面那些集合 $S_{j+1},\cdots ,S_m$ 满足引理的条件，因而能够组成 SGS。

初始时，我们设置$$m=1,B=({\beta }_1),S_1=X,j=1,$$其中 ${\beta }_1$ 是任意一个至少被 $X$ 中某个置换移动的元素，这样可以保证无赘余。
初始化之后进入循环。每次循环开始时，首先对群 $⟨S_j⟩$ 和元素 ${\beta }_j$ 使用之前介绍的算法，计算轨道和 transversal。然后检验 $⟨S_j{⟩}_{{\beta }_j}$ 的所有 Schreier 生成元是否都属于 $⟨S_{j+1}⟩$（用筛选过程检验属于关系，因为我们已经拥有了 $⟨S_{j+1}⟩$ 的一组基 $({\beta }_{j+1},\cdots ,{\beta }_m)$ 以及相应的 SGS ${\bigcup }_{i=j+1}^m{S}_i$），也就是检验 $⟨S_j{⟩}_{{\beta }_j}$ 是否是 $⟨S_{j+1}⟩$ 的子群。结果有以下两种。

• $⟨S_j{⟩}_{{\beta }_j}\le ⟨S_{j+1}⟩$，此时直接令 $j$ 自减 $1$。

这里没什么好说的，我们需要维护的性质显然还是成立的。

• $⟨S_j{⟩}_{{\beta }_j}̸\le ⟨S_{j+1}⟩$，失败原因是 $⟨S_j{⟩}_{{\beta }_j}$ 的某个生成元 $g$ 不属于 $⟨S_{j+1}⟩$。此时将筛选过程返回的 siftee（记为 $h$）添入 $S_{j+1}$ 中，并令 $j$ 自增 $1$。如果 $j=m$，则令 $m$ 也自增 $1$，并取 ${\beta }_m$ 为任意一个被置换 $h$ 移动的元素。

这里需要检验一下需要维护的性质是否仍然成立。因为 $⟨S_{j+1}⟩$ 的基是 $({\beta }_{j+1},\cdots ,{\beta }_m)$，并且已知 $g$ 固定 ${\beta }_1,\cdots ,{\beta }_j$ 不动，从而筛选过程可将 $g$ 分解为$$g=h{r}_i{r}_{i-1}\cdots r_{j+1},r_k\in R_k(j<k\le i),h̸=1,j\le i\le m,$$并且 $h$ 固定 ${\beta }_1,\cdots ,{\beta }_i$ 不动。于是将 $h$ 添入 $S_{j+1}$ 之后就离 $⟨S_j{⟩}_{{\beta }_j}=⟨S_{j+1}⟩$ 更近了一步。但是 $⟨S_{j+1}{⟩}_{{\beta }_{j+1}}=⟨S_{j+2}⟩$ 此时可能不再成立，因此需要让 $j$ 自增 $1$。真正需要验证的是 $⟨S_i⟩\ge ⟨S_{i+1}⟩$ 是否仍成立，这是显然的（$h$ 显然属于 $⟨S_j⟩$）。$h$ 属于 $G^{[j+1]}$ 也是显然的。
对于 $j=m$ 的情况要特别讨论，因为我们将 $h$ 添入 $S_{m+1}$ 中显然违反了 $S_{m+1}=\varnothing$ 的规定。此时考虑让 $m$ 自增 $1$，并取 ${\beta }_m$ 为任意一个被置换 $h$ 移动的元素，这样就能保证 $G^{[m]}$ 有一个移动了 ${\beta }_m$ 的元素。

终止条件为 $j=0$，此时 $B$ 是一组无赘余的基，$S={\bigcup }_{i=1}^m{S}_i$ 是 $G$ 关于 $B$ 的 SGS。

接下来证明该算法一定能终止，并讨论时间复杂度。注意到：

• 基 $B=({\beta }_1,\cdots ,{\beta }_m)$ 的长度是 $O(\log |G|)$；
• 每个 $S_k$ 扩张的次数是 $O(\log |G|)$，因为每次扩张都会使 $⟨S_k⟩$ 的阶严格增加，从而至少变为原来的 $2$ 倍；（至此已经说明该算法一定会终止）
• 每次扩张 $S_k$ 时都需要重新计算 $⟨S_k⟩,{\beta }_k$ 对应的轨道和 transversal。但是庆幸的是，我们不必推倒重来：原先已经确定属于 ${\Delta }_k$ 的元素无论是 Schreier 向量的值还是直接存储 $u_{\beta }$ 值，都没必要重算了。换句话说，在整个算法过程中，对任意 $\gamma \in \Omega$ 和 $g\in S_k$ 都只需要计算一次 ${\gamma }^g$。因此这一部分的时间复杂度为 $O(|B|\log |G|n+|X|n)$（因为 $S_1$ 初始时有 $|X|$ 个元素），也就是 $O(n{\log }^2|G|+|X|n)$。
• 如果我们需要显式存储 transversal（即直接计算 $u_{\beta }$ 值并存储），注意对每个 $S_k$ 和 ${\beta }_k$，搜索时 $\Omega$ 中每个元素最多只会访问一次（即使考虑 $S_k$ 的动态扩充也一样，因为已经算过的没必要重算），也就是说为了计算 $u_{\beta }$ 值，需要计算 $O(n)$ 次置换复合，每次用时 $O(n)$，因此这一部分额外的时间复杂度为 $O(n^2\log |G|)$。
• 最后考虑检验 $⟨S_j{⟩}_{{\beta }_j}\le ⟨S_{j+1}⟩$ 是否成立的开销，此时注意对任意 $(\beta ,s)\in {\Delta }_k\times S_k$，我们只会计算一次 $u_{\beta }s{u}_{{\beta }^s}^{-1}$ 的值并进行筛选过程，因为如果结果是它属于 $⟨S_{k+1}⟩$，那以后肯定也一直属于，没必要再算了；如果不属于 $⟨S_{k+1}⟩$，那把 siftee 添入 $S_{k+1}$ 之后 $u_{\beta }s{u}_{{\beta }^s}^{-1}$ 就自动属于 $⟨S_{k+1}⟩$ 了，以后也没必要再算。因此整个算法过程中 ${\Delta }_k\times S_k$ 的每个元素只需遍历一遍，再对 $1\le k\le m$ 做加总，次数为 $O(n{\log }^2|G|+|X|n)$。
  此处体现了显式存储 transversal 的长处，可以在常数时间内得到 $u_{\beta }$，之后每次筛选操作只需进行 $O(\log |G|)$ 次置换复合，于是该部分的时间开销就是 $O(n^2{\log }^3|G|+|X|n^2\log |G|)$。如果不显式计算 transversal 而用 Schreier 向量存储，那每次得到 $u_{\beta }$ 的最坏时间复杂度就是 $O(n^2)$（此时置换复合的时间复杂度就不是主要矛盾了），这一操作需要进行 $O(\log |G|)$ 次，该部分的时间开销就是 $O(n^3{\log }^3|G|+|X|n^3\log |G|)$。

至此可以断定：

如果显式存储 transversal，算法的时间复杂度为 $O(n^2{\log }^3|G|+|X|n^2\log |G|)$；如果用 Schreier 向量间接存储 transversal，算法的时间复杂度为 $O(n^3{\log }^3|G|+|X|n^3\log |G|)$。

现在看空间复杂度，显然空间复杂度的主要部分是 $S_k$，所有 $S_k$ 的元素总数是 $O({\log }^2|G|)$（这里没有考虑初始的 $|X|$ 个生成元占的空间，只考虑额外空间），因此空间复杂度为 $O(n{\log }^2|G|)$。如果显式存储 transversal，则要算上存储 transversal 耗费的空间，对每个 $S_k$ 和每个 $\beta \in {\Delta }_k$ 都要存储置换 $u_{\beta }$，从而这一部分的空间复杂度是 $O(n^2\log |G|)$。这样就得到了空间复杂度的结论：

如果显式存储 transversal，算法的空间复杂度为 $O(n^2\log |G|+n{\log }^2|G|+|X|n)$；如果用 Schreier 向量间接存储 transversal，算法的空间复杂度为 $O(n{\log }^2|G|+|X|n)$。

事实上第一种情况的空间复杂度可以确定为 $O(n^2\log |G|+|X|n)$，因为可以证明对称群 $S_n$ 的真子群链长度至多为 $O(n)$——这说明每个 $S_k$ 的元素个数都是 $O(n)$，从而所有 $S_k$ 的元素总数是 $O(n\log |G|)$，即 $S_k$ 所占空间也是 $O(n^2\log |G|)$。现在重新叙述一遍空间复杂度的结论。

如果显式存储 transversal，算法的空间复杂度为 $O(n^2\log |G|+|X|n)$；如果用 Schreier 向量间接存储 transversal，算法的空间复杂度为 $O(n{\log }^2|G|+|X|n)$。

总结

介绍完 Schreier-Sims 算法，本文也就该结束了，但是 Schreier-Sims 算法的相关内容远不止这些，可以说这里水很深。

例如通过 Schreier 向量计算 $u_{\beta }$ 的最坏时间复杂度是 $O(n^2)$，可能读者会觉得这个时间上限太粗糙了，通常情况下的时间复杂度要比这好得多。但按照本文介绍的算法，已经算过的 Schreier 树不会再更新，偏偏我们在初始化 $S_k(k>1)$ 时只添了一个元素，这时构建的树的深度很容易过高，而它一旦定形就不会再更改了！一种改进方法是每次更新 $S_k$ 时都重新算一遍 Schreier 树，但这种操作需要小心行事，如果原先的 Schreier 树不深，再算一遍就是浪费时间了。

对第一种算法（显式存储 Schreier 树），时间复杂度是 $O(n^5)$（此处需要利用对称群 $S_n$ 的真子群链长度至多为 $O(n)$ 的结论），Knuth 在 1991 年给出了一组数据 $X$，使得算法的时间复杂度达到 $\Theta (n^5)$。如果 $X$ 是随机选取的，通常认为期望时间复杂度是 $\Theta (n^4)$。

对 Schreier-Sims 算法稍作改进，可以消除时间复杂度第二项的一个 $n$ 因子。Schreier-Sims 算法还有一种运用 Monte Carlo 方法的改进，可以做到时间复杂度 $O(n\log n{\log }^4|G|+|X|n\log |G|)$，空间复杂度 $O(n\log |G|+|X|n)$。这些就只能在下一篇文章里再讲了（如果有的话）。

参考文献

[1] Seress, A. Permutation Group Algorithms, Cambridge U Press, 2002.
[2] Derek F. Holt, Bettina Eick, Eamonn A. O’Brien, “Handbook of computational group theory”, Discrete Mathematics and its Applications (Boca Raton). Chapman & Hall/CRC, Boca Raton, Florida, 2005. ISBN 1-58488-372-3
[3] Cameron, P. J., Solomon, R., and Turull, A. (1989). Chains of
subgroups in symmetric groups. J. Algebra, 127:340–352.
[4] Knuth, D. E. (1991). Notes on efficient representation of perm groups.
Combinatorica, 11:57–68.