群论与Sage¶
这本汇编收集了Sage命令，对学生在群体理论的入门课程中是有用的。它不是为了教Sage或教授群体理论。（有许多关于群体理论的介绍性文本，关于Sage的更多信息可以通过 www.sagemath.org )相反，通过大致按照学生学习相应数学的顺序给出命令，可以鼓励他们进行实验，学习更多的数学知识，学习更多关于Sage的知识。无独有偶，当Sage是Sage的缩写时，Sage中的“E”代表“实验”
本指南也以PDF格式和Sage工作表的形式分发。工作表版本可以导入到运行在web浏览器中的Sage笔记本环境中，然后单击每个单元格下面的小“evaluate”链接，Sage就可以执行显示的代码块，从而获得完全交互的体验。本教程的PDF和Sage工作表版本可在http://abstract.ups.edu/sage-aata.html。
变更日志：
2009年1月30日第一版
2009/03/03版本1.1，添加了循环组大小交互
2010/03/10版本1.3，删除了我们的许可证，一些编辑。
整数的基本性质¶
整数除法¶
命令 a % b 将在除法时返回余数 a 通过 b . 换句话说，该值是唯一的整数 r 因此：
0 leq r < b ；和
a = bq + r 对于某个整数 q （商）。
然后 (a - r) / b 意志平等 q . 例如：：
sage: r = 14 % 3
sage: q = (14 - r) / 3
sage: r, q
(2, 4)
将返回 2 for the value of r and 4 for the value of q. Note that the "/" is integer division, where any remainder is cast away and the result is always an integer. So, for example, `` 14/3``将再次相等 4 不是 4.66666 .
最大公约数¶
最大公约数 a 和 b 通过命令获得 gcd(a,b) ，在我们第一次使用时， a 和 b 是整数。后来， a 和 b 也可以是具有可除性和“伟大”概念的其他对象，如多项式。例如：：
sage: gcd(2776, 2452)
4
扩展最大公约数¶
命令 xgcd(a, b) （“eXtended GCD”）返回一个三元组，其中第一个元素是 a 和 b （和 gcd(a, b) 命令），但接下来的两个元素是 r 和 s 这样的话 ra + sb = gcd(a, b) . 例如， xgcd(633, 331) 收益率 (1, 194, -371) . 可以使用 [ ] 访问三元组的条目，从第一个作为数字开始 0 . 例如，下面应该返回结果 True （即使您更改 a 和 b ). 研究这段代码将有助于您最大限度地利用Sage的输出。（请注意，“=`”是如何将值赋给变量的，而在最后一行，==`”是确定两个项相等的方式。）：
sage: a = 633
sage: b = 331
sage: extended = xgcd(a, b)
sage: g = extended[0]
sage: r = extended[1]
sage: s = extended[2]
sage: g == r*a + s*b
True
可分性¶
余数为零表示可除性。所以 (a % b) == 0 将返回 True 如果 b 分水岭 a ，否则将返回 False . 例如， (9 % 3) == 0 是 True ，但是 (9 % 4) == 0 是 False . 在Sage中执行以下命令之前，请尝试预测它的输出。:
sage: answer1 = ((20 % 5) == 0)
sage: answer2 = ((17 % 4) == 0)
sage: answer1, answer2
(True, False)
保理¶
正如算术基本定理所承诺的那样， factor(a) 将返回的唯一表达式 a 作为素数幂的乘积。它将以可读性很好的形式打印出来，但也可以用Python作为对列表进行操作 (p_i, e_i) 以素数为基的包含素数及其相关指数的。例如：：
sage: factor(2600)
2^3 * 5^2 * 13
如果只需要整数的素数，则使用 prime_divisors(a) 命令，它将返回 a . 例如：：
sage: prime_divisors(2600)
[2, 5, 13]
我们可以使用两个层次的 [ ] . 为了学习如何深入到Python列表中，这是另一个值得研究的好例子。:
sage: n = 2600
sage: decomposition = factor(n)
sage: print("{} decomposes as {}".format(n, decomposition))
2600 decomposes as 2^3 * 5^2 * 13
sage: secondterm = decomposition[1]
sage: print("Base and exponent (pair) for second prime: "+str(secondterm))
Base and exponent (pair) for second prime: (5, 2)
sage: base = secondterm[0]
sage: exponent = secondterm[1]
sage: print("Base is "+str(base))
Base is 5
sage: print("Exponent is "+str(exponent))
Exponent is 2
sage: thirdbase = decomposition[2][0]
sage: thirdexponent = decomposition[2][1]
sage: print("Base of third term is {} with exponent {}".format(thirdbase, thirdexponent))
Base of third term is 13 with exponent 1
再多做点工作 factor() 命令可用于计算更复杂的项目，如多项式。
乘法逆，模运算¶
命令 inverse_mod(a, n) 得到的乘法逆 a 国防部 n （如果不存在，则为错误）。例如：：
sage: inverse_mod(352, 917)
508
（作为检查，找到整数 m 这样的话 352*508 == m*917+1 ）然后试试：
sage: inverse_mod(4, 24)
Traceback (most recent call last):
...
ZeroDivisionError: inverse of Mod(4, 24) does not exist
并解释结果。
模运算幂¶
命令 power_mod(a, m, n) 产量 a^m 国防部 n . 例如：：
sage: power_mod(15, 831, 23)
10
如果 m = -1 ，则此命令将复制 inverse_mod() .
欧拉 phi -功能¶
命令 euler_phi(n) 将返回小于 n 相对最好的 n （即有最大的公约数 n 等于1）。例如：：
sage: euler_phi(345)
176
通过多次运行以下代码进行实验：
sage: m = random_prime(10000)
sage: n = random_prime(10000)
sage: euler_phi(m*n) == euler_phi(m) * euler_phi(n)
True
感觉到一个猜想出现了吗？你能概括一下这个结果吗？
素数¶
命令 is_prime(a) 收益率 True 或 False 取决于如果 a 是不是质数。例如：：：
sage: is_prime(117371)
True
时间：：
sage: is_prime(14547073)
False
自从 14547073 = 1597 * 9109 （你可以用 factor() 命令）。
命令 random_prime(a, True) 将返回一个介于2和之间的随机素数 a . 试验方法：
sage: p = random_prime(10^21, True)
sage: is_prime(p)
True
（替换 True 通过 False 会加快搜索速度，但结果不是质数的可能性很小。）
命令 prime_range(a, b) 返回中所有素数的有序列表 a 到 b - 1 ，包括在内。例如：：：
sage: prime_range(500, 550)
[503, 509, 521, 523, 541, 547]
命令 next_prime(a) 和 previous_prime(a) 还有其他方法可以得到一个理想大小的单个质数。试试看。
置换群¶
Sage对群论的支持很大一部分是基于GAP的例程（组、算法和http://www.gap-system.org。群可以用许多不同的方式来描述，例如矩阵集或符号集，它们受几个定义关系的约束。表示群的一种非常具体的方法是通过置换（一对一和整数1到整数的函数） n )，在组中使用函数组合作为操作。Sage有许多与这类群体合作的程序，它们也是学习群体理论的人获得群体理论基本思想经验的好方法。基于这两个原因，我们将集中讨论这些类型的群体。
书写排列¶
Sage使用“不相交循环表示法”进行排列，更多信息请参见任何关于群论的介绍性文本（如Judson，第4.1节）。合成发生 从左到右 ，这并不是你所期望的，恰恰与朱德森和其他许多人使用的相反。（支持这两个方向都有很好的理由，你只需要确定你知道哪个方向在起作用） sigma = (1,3) (2,5,4) ：
作为文本字符串（包括引号）：
"(1,3) (2,5,4)"作为“元组”的Python列表：
[(1,3), (2,5,4)]
组¶
Sage知道许多流行的组是一组排列。下面列出了更多的，但是对于初学者来说，是所有可能的1到1排列的完整“对称群” n 可以使用命令生成 SymmetricGroup(n) .
排列元素 可以按如下方式创建和组合组元素：
sage: G = SymmetricGroup(5)
sage: sigma = G("(1,3) (2,5,4)")
sage: rho = G([(2,4), (1,5)])
sage: rho^(-1) * sigma * rho
(1,2,4)(3,5)
置换群元素的可用函数包括寻找元素的顺序，即排列的顺序 sigma 顺序是 k 这样的话 sigma^k 等于标识元素 () . 例如：：
sage: G = SymmetricGroup(5)
sage: sigma = G("(1,3) (2,5,4)")
sage: sigma.order()
6
排列的符号 sigma 对于偶数置换定义为1，并且 -1 对于一个奇怪的排列。例如：：
sage: G = SymmetricGroup(5)
sage: sigma = G("(1,3) (2,5,4)")
sage: sigma.sign()
-1
自从 sigma 是一个奇怪的排列。
可以通过“制表符完成”找到更多可用于排列的可用函数 sigma defined as an element of a permutation group, in a Sage cell, type sigma. （注意“.`”）然后按tab键。您将获得可用功能的列表（您可能需要向下滚动以查看整个列表）。实验和探索！这就是Sage的全部。你真的不能打破任何东西。
创建组¶
这是一些小的已知排列组的注释列表，可以在Sage中简单地创建。您可以在源代码文件中找到更多：
SAGE_ROOT/src/sage/groups/perm_gps/permgroup_named.py
SymmetricGroup(n): All n! permutations on n symbols.DihedralGroup(n)：对称性 n -刚。旋转和翻转， 2n 总共。CyclicPermutationGroup(n)：旋转 n -gon（禁止翻身）， n 总共。AlternatingGroup(n)：交替组开 n 具有 n!/2 元素。KleinFourGroup()：4阶非循环群。
组函数¶
排列群的单个元素很重要，但我们主要希望将组作为单独的对象来研究。因此，各种各样的计算方法可用于组。定义组，例如：
sage: H = DihedralGroup(6)
sage: H
Dihedral group of order 12 as a permutation group
然后就有了各种各样的功能。
在尝试了下面的示例之后，尝试使用制表符完成。定义 H, type H. （注意“.`”）然后按tab键。您将获得可用功能的列表（您可能需要向下滚动以查看整个列表）。和以前一样， 实验与探索 ---打破任何东西都很难。
下面是另一对实验和探索的方法。找一个看起来有趣的函数，比如说 is_abelian() . 类型 H.is_abelian? （注意问号）后跟回车键。这将显示 is_abelian() 函数，描述输入和输出，可能用示例说明。
如果您想了解Sage是如何工作的，或者可能扩展它的功能，那么可以从检查完整的Python源代码开始。例如，试试看 H.is_abelian?? ，这将允许您确定 is_abelian() 功能基本上依赖于GAP的 IsAbelian() 命令并要求盖普为我们做重担。（要获得使用Sage的最大优势，了解一些基本的Python编程是有帮助的，但这不是必需的。）
好的，来看看一些流行的团体命令。如果正在使用工作表，请确保已定义组 H 作为二面体群 D_6 ，因为我们不会重复下面的定义。
所有元素¶
命令：
sage: H = DihedralGroup(6)
sage: H.list()
[(),
(1,5,3)(2,6,4),
(1,3,5)(2,4,6),
(1,6,5,4,3,2),
(1,4)(2,5)(3,6),
(1,2,3,4,5,6),
(2,6)(3,5),
(1,5)(2,4),
(1,3)(4,6),
(1,6)(2,5)(3,4),
(1,4)(2,3)(5,6),
(1,2)(3,6)(4,5)]
将返回的所有元素 H 以固定的顺序作为Python列表。索引 ([ ] )可用于提取列表中的各个元素，记住列表元素的计数从零开始。:
sage: H = DihedralGroup(6)
sage: elements = H.list()
sage: elements[2]
(1,3,5)(2,4,6)
凯利桌¶
命令：
sage: H = DihedralGroup(6)
sage: H.cayley_table()
* a b c d e f g h i j k l
+------------------------
a| a b c d e f g h i j k l
b| b a d c f e h g j i l k
c| c k a e d g f i h l b j
d| d l b f c h e j g k a i
e| e j k g a i d l f b c h
f| f i l h b j c k e a d g
g| g h j i k l a b d c e f
h| h g i j l k b a c d f e
i| i f h l j b k c a e g d
j| j e g k i a l d b f h c
k| k c e a g d i f l h j b
l| l d f b h c j e k g i a
将构造 H . 默认情况下，表使用小写拉丁字母来命名组中的元素。可以使用 row_keys() 或 column_keys() 用于表的命令。例如，要确定表中的第五个元素，名为 e ：：
sage: H = DihedralGroup(6)
sage: T = H.cayley_table()
sage: headings = T.row_keys()
sage: headings[4]
(1,3)(4,6)
中心¶
命令 H.center() 将返回作为组中心的子组 H （见Judson中的练习2.46）。尝试：：
sage: H = DihedralGroup(6)
sage: H.center().list()
[(), (1,4)(2,5)(3,6)]
查看 H 通勤 每一个 元素 H .
凯莱图¶
为了好玩，试试看 show(H.cayley_graph()) .
子组¶
循环子群¶
如果 G 是一个团体 a 是组的一个元素（try a = G.random_element() )，则：
a = G.random_element()
H = G.subgroup([a])
将创造 H 作为循环子群 G 带发电机 a .
例如，下面的代码将：
创造
G作为五个符号的对称群；指定
sigma作为一个元素G；使用
sigma作为循环子群的生成元H；列出的所有元素
H.
用更数学的表示法，我们可以写 langle (1,2,3) (4,5) rangle = H subseteq G = S_5 . ：：
sage: G = SymmetricGroup(5)
sage: sigma = G("(1,2,3) (4,5)")
sage: H = G.subgroup([sigma])
sage: H.list()
[(), (1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5)]
通过尝试不同的排列来进行实验 sigma 并观察 H .
循环群¶
本身是循环的群既重要又结构丰富。命令 CyclicPermutationGroup(n) 将创建循环的置换组 n 元素。考虑下面的例子（注意第三行的缩进是关键的），它将列出顺序为20的循环组中的元素，前面是每个元素的顺序。:
sage: n = 20
sage: CN = CyclicPermutationGroup(n)
sage: for g in CN:
....: print("{} {}".format(g.order(), g))
1 ()
20 (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
10 (1,3,5,7,9,11,13,15,17,19)(2,4,6,8,10,12,14,16,18,20)
20 (1,4,7,10,13,16,19,2,5,8,11,14,17,20,3,6,9,12,15,18)
5 (1,5,9,13,17)(2,6,10,14,18)(3,7,11,15,19)(4,8,12,16,20)
4 (1,6,11,16)(2,7,12,17)(3,8,13,18)(4,9,14,19)(5,10,15,20)
10 (1,7,13,19,5,11,17,3,9,15)(2,8,14,20,6,12,18,4,10,16)
20 (1,8,15,2,9,16,3,10,17,4,11,18,5,12,19,6,13,20,7,14)
5 (1,9,17,5,13)(2,10,18,6,14)(3,11,19,7,15)(4,12,20,8,16)
20 (1,10,19,8,17,6,15,4,13,2,11,20,9,18,7,16,5,14,3,12)
2 (1,11)(2,12)(3,13)(4,14)(5,15)(6,16)(7,17)(8,18)(9,19)(10,20)
20 (1,12,3,14,5,16,7,18,9,20,11,2,13,4,15,6,17,8,19,10)
5 (1,13,5,17,9)(2,14,6,18,10)(3,15,7,19,11)(4,16,8,20,12)
20 (1,14,7,20,13,6,19,12,5,18,11,4,17,10,3,16,9,2,15,8)
10 (1,15,9,3,17,11,5,19,13,7)(2,16,10,4,18,12,6,20,14,8)
4 (1,16,11,6)(2,17,12,7)(3,18,13,8)(4,19,14,9)(5,20,15,10)
5 (1,17,13,9,5)(2,18,14,10,6)(3,19,15,11,7)(4,20,16,12,8)
20 (1,18,15,12,9,6,3,20,17,14,11,8,5,2,19,16,13,10,7,4)
10 (1,19,17,15,13,11,9,7,5,3)(2,20,18,16,14,12,10,8,6,4)
20 (1,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2)
通过改变组的大小（更改 n )你可以开始说明循环群的一些结构（例如，尝试素数）。
我们可以从上面的输出中剪切/粘贴顺序为5的元素（如果循环组有20个元素），然后快速构建一个子组：
sage: C20 = CyclicPermutationGroup(20)
sage: rho = C20("(1,17,13,9,5)(2,18,14,10,6)(3,19,15,11,7)(4,20,16,12,8)")
sage: H = C20.subgroup([rho])
sage: H.list()
[(),
(1,17,13,9,5)(2,18,14,10,6)(3,19,15,11,7)(4,20,16,12,8),
(1,13,5,17,9)(2,14,6,18,10)(3,15,7,19,11)(4,16,8,20,12),
(1,9,17,5,13)(2,10,18,6,14)(3,11,19,7,15)(4,12,20,8,16),
(1,5,9,13,17)(2,6,10,14,18)(3,7,11,15,19)(4,8,12,16,20)]
对于循环组，以下命令将列出 all 在小组中。:
sage: C20 = CyclicPermutationGroup(20)
sage: C20.conjugacy_classes_subgroups()
[Subgroup generated by [()] of (Cyclic group of order 20 as a permutation group),
Subgroup generated by [(1,11)(2,12)(3,13)(4,14)(5,15)(6,16)(7,17)(8,18)(9,19)(10,20)] of (Cyclic group of order 20 as a permutation group),
Subgroup generated by [(1,6,11,16)(2,7,12,17)(3,8,13,18)(4,9,14,19)(5,10,15,20), (1,11)(2,12)(3,13)(4,14)(5,15)(6,16)(7,17)(8,18)(9,19)(10,20)] of (Cyclic group of order 20 as a permutation group),
Subgroup generated by [(1,5,9,13,17)(2,6,10,14,18)(3,7,11,15,19)(4,8,12,16,20)] of (Cyclic group of order 20 as a permutation group),
Subgroup generated by [(1,3,5,7,9,11,13,15,17,19)(2,4,6,8,10,12,14,16,18,20), (1,5,9,13,17)(2,6,10,14,18)(3,7,11,15,19)(4,8,12,16,20)] of (Cyclic group of order 20 as a permutation group),
Subgroup generated by [(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20), (1,3,5,7,9,11,13,15,17,19)(2,4,6,8,10,12,14,16,18,20), (1,5,9,13,17)(2,6,10,14,18)(3,7,11,15,19)(4,8,12,16,20)] of (Cyclic group of order 20 as a permutation group)]
注意，这个命令使用了一些更高级的思想，通常不会列出 all 一个群的子群。这里我们依赖于循环群的特殊性质（见下一节）。
如果您是以PDF格式查看的，可以安全地跳过下一段代码。但是，如果您在Sage中将其视为一个工作表，那么您可以在这里试验循环组的子组的结构。在输入框中，输入循环组的顺序（1到40之间的数字是很好的初始选择），Sage将把每个子组作为循环组及其生成器列出。底部的因子分解可能有助于你形成一个猜想。:
%auto
@interact
def _(n = input_box(default=12, label = "Cyclic group of order:", type=Integer) ):
cyclic = CyclicPermutationGroup(n)
subgroups = cyclic.conjugacy_classes_subgroups()
html( "All subgroups of a cyclic group of order $%s$\n" % latex(n) )
table = "$\\begin{array}{ll}"
for sg in subgroups:
table = table + latex(sg.order()) + \
" & \\left\\langle" + latex(sg.gens()[0]) + \
"\\right\\rangle\\\\"
table = table + "\\end{array}$"
html(table)
html("\nHint: $%s$ factors as $%s$" % ( latex(n), latex(factor(n)) ) )
所有子组¶
如果 H 是 G 和 g in G 然后 gHg^{{-1}} = {{ghg^{{-1}} mid h in G}} 也将是 G .如果 G 是一个组，那么命令 G.conjugacy_classes_subgroups() 将返回的子组列表 G ，但不是所有的子组。但是，每个子组都可以通过 gHg^{{-1}} 与合适的 g . 作为说明，下面的代码：
创造
K作为24阶二面体群， D_{{12}} ；存储输出的子组列表
K.conjugacy_classes_subgroups()变量中sg；打印列表的元素；
选择列表中的第二个子组，并列出其元素。
sage: K = DihedralGroup(12)
sage: sg = K.conjugacy_classes_subgroups()
sage: sg
[Subgroup generated by [()] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,7)(2,8)(3,9)(4,10)(5,11)(6,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,2)(3,12)(4,11)(5,10)(6,9)(7,8)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,7)(2,8)(3,9)(4,10)(5,11)(6,12), (1,10,7,4)(2,11,8,5)(3,12,9,6)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,2)(3,12)(4,11)(5,10)(6,9)(7,8), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,3,5,7,9,11)(2,4,6,8,10,12), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,2)(3,12)(4,11)(5,10)(6,9)(7,8), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12), (1,10,7,4)(2,11,8,5)(3,12,9,6)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8), (1,3,5,7,9,11)(2,4,6,8,10,12), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,2,3,4,5,6,7,8,9,10,11,12), (1,3,5,7,9,11)(2,4,6,8,10,12), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(1,2)(3,12)(4,11)(5,10)(6,9)(7,8), (1,3,5,7,9,11)(2,4,6,8,10,12), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group),
Subgroup generated by [(2,12)(3,11)(4,10)(5,9)(6,8), (1,2,3,4,5,6,7,8,9,10,11,12), (1,3,5,7,9,11)(2,4,6,8,10,12), (1,5,9)(2,6,10)(3,7,11)(4,8,12)] of (Dihedral group of order 24 as a permutation group)]
sage: print("An order two subgroup:\n{}".format(sg[1].list()))
An order two subgroup:
[(), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)]
需要注意的是，这是一个很长的子组列表，但很少会创建 每一个 这样的子群。例如，下面的代码：
创造
rho作为团队的一员K；创造
L作为循环子群K；打印
L；最后测试此子组是否是列表输出的一部分
sg就在上面创建的（它不是）。
sage: K = DihedralGroup(12)
sage: sg = K.conjugacy_classes_subgroups()
sage: rho = K("(1,4) (2,3) (5,12) (6,11) (7,10) (8,9)")
sage: L = PermutationGroup([rho])
sage: L.list()
[(), (1,4)(2,3)(5,12)(6,11)(7,10)(8,9)]
sage: L in sg
False
对称群¶
你可以给Sage一个排列组元素的简短列表，Sage将找到包含这些元素的最小子组。我们说列表“生成”了子组。我们列出了几个可以用这种方法创建的有趣的子组。
等边三角形的对称性¶
将等边三角形的顶点标记为1、2和3。那么 any 顶点的排列将是三角形的对称性。所以也一样 SymmetricGroup(3) 或 DihedralGroup(3) 将创建完全对称组。
对称性 n -冈州¶
一个普通人， n -平面上的侧面图形（一个 n -gon）有 2n 对称性，包括 n 旋转（包括琐碎的旋转）和 n 在不同的轴上“翻转”。二面体群 DihedralGroup(n) 通常被定义为 n -刚。
四面体的对称性¶
将正四面体的4个顶点标记为1、2、3和4。固定标记为4的顶点并将对面旋转120度。这将创建排列/对称 (1,2, 3) . 类似地，固定顶点1并旋转相反的面将创建置换 (2,3,4) . 这两个排列足以产生四面体十二个对称性的全群。另一种对称性可以通过使一个轴穿过四面体的一个边的中点到另一个边的中点，然后围绕这个轴旋转180度。例如，1-2边与3-4边相对，对称性用置换来描述 (1,2) (3,4) . 这个排列，连同上面的任何一个排列，也将生成组。所以有两种方法可以创建这个组：
sage: tetra_one = PermutationGroup(["(1,2,3)", "(2,3,4)"])
sage: tetra_one
Permutation Group with generators [(2,3,4), (1,2,3)]
sage: tetra_two = PermutationGroup(["(1,2,3)", "(1,2)(3,4)"])
sage: tetra_two
Permutation Group with generators [(1,2)(3,4), (1,2,3)]
这个群体有很多有趣的特性，所以值得一试。你们也知道，在Sage的命令下，你们也会创造出符号 AlternatingGroup(4) .
立方体的对称性¶
用1、2、3和4标记立方体的一个面上的顶点，在另一个面上标记顶点5、6、7和8（5个相对1，6个相对2，等等）。考虑从一个面中心到另一个面的中心的三个轴，并考虑围绕每个轴旋转四分之一圈。这三个旋转将构成整个对称群。用途：
sage: cube = PermutationGroup(["(3,2,6,7)(4,1,5,8)",
....: "(1,2,6,5)(4,3,7,8)", "(1,2,3,4)(5,6,7,8)"])
sage: cube.list()
[(),
(1,3)(2,4)(5,7)(6,8),
(1,6)(2,5)(3,8)(4,7),
(1,8)(2,7)(3,6)(4,5),
(1,4,3,2)(5,8,7,6),
(1,2,3,4)(5,6,7,8),
(1,5)(2,8)(3,7)(4,6),
(1,7)(2,6)(3,5)(4,8),
(2,5,4)(3,6,8),
(1,3,8)(2,7,5),
(1,6,3)(4,5,7),
(1,8,6)(2,4,7),
(1,4)(2,8)(3,5)(6,7),
(1,2,6,5)(3,7,8,4),
(1,5,6,2)(3,4,8,7),
(1,7)(2,3)(4,6)(5,8),
(2,4,5)(3,8,6),
(1,3,6)(4,7,5),
(1,6,8)(2,7,4),
(1,8,3)(2,5,7),
(1,4,8,5)(2,3,7,6),
(1,2)(3,5)(4,6)(7,8),
(1,5,8,4)(2,6,7,3),
(1,7)(2,8)(3,4)(5,6)]
立方体有四条不同的对角线（通过立方体的中心连接相反的顶点）。立方体的每一个对称性都会导致对角线的排列方式不同。这样，我们就可以把对称群的一个元素看成是四个“符号”——对角线的排列。碰巧是这样 each 在24个对角线排列中，正是由立方体的8个顶点的一个对称性创建的。所以这个小组 S_8 是“一样的” S_4 . 塞奇语：
sage: cube = PermutationGroup(["(3,2,6,7)(4,1,5,8)",
....: "(1,2,6,5)(4,3,7,8)", "(1,2,3,4)(5,6,7,8)"])
sage: cube.is_isomorphic(SymmetricGroup(4))
True
将测试立方体的对称性组是否“相同” S_4 也会回来的 True .
这是另一种创建立方体对称性的方法。数六 面孔 立方体如下：1在上面，2在下面，3在前面，4在右边，5在后面，6在左边。现在，与之前相同的旋转（通过两个相对面的中心绕轴旋转四分之一圈）可以用作对称组的生成器：
sage: cubeface = PermutationGroup(["(1,3,2,5)", "(1,4,2,6)", "(3,4,5,6)"])
sage: cubeface.list()
[(),
(3,5)(4,6),
(1,6,5)(2,4,3),
(1,6,3)(2,4,5),
(1,5,6)(2,3,4),
(1,5,4)(2,3,6),
(1,2)(4,6),
(1,2)(3,5),
(1,4,5)(2,6,3),
(1,4,3)(2,6,5),
(1,3,4)(2,5,6),
(1,3,6)(2,5,4),
(1,4,2,6),
(1,6)(2,4)(3,5),
(1,3,2,5),
(1,5,2,3),
(1,2)(3,4)(5,6),
(3,6,5,4),
(1,6,2,4),
(1,4)(2,6)(3,5),
(1,5)(2,3)(4,6),
(1,3)(2,5)(4,6),
(3,4,5,6),
(1,2)(3,6)(4,5)]
同样，这个小组 S_6 与全对称群“相同”， S_4 ：：
sage: cubeface = PermutationGroup(["(1,3,2,5)", "(1,4,2,6)", "(3,4,5,6)"])
sage: cubeface.is_isomorphic(SymmetricGroup(4))
True
结果表明，在上述每种结构中，仅使用三个发电机中的两个（任意两个）就足够了。但一台发电机是不够的。试一试，用Sage说服自己，在每种情况下都可以牺牲一个发电机。
正规子群¶
检查正态性¶
代码如下：
从交替组开始 A_4 ；
指定组的三个元素（四面体的三个对称性，即围绕轴通过相对边的中点旋转180度）；
使用这三个元素生成子组；最后
说明用于测试子组
H是组的正规子群A4.
sage: A4 = AlternatingGroup(4)
sage: r1 = A4("(1,2) (3,4)")
sage: r2 = A4("(1,3) (2,4)")
sage: r3 = A4("(1,4) (2,3)")
sage: H = A4.subgroup([r1, r2, r3])
sage: H.is_normal(A4)
True
群商¶
扩展前面的示例，我们可以创建 A_4 通过 H . 命令：
sage: A4 = AlternatingGroup(4)
sage: r1 = A4("(1,2) (3,4)")
sage: r2 = A4("(1,3) (2,4)")
sage: r3 = A4("(1,4) (2,3)")
sage: H = A4.subgroup([r1, r2, r3])
sage: A4.quotient(H)
Permutation Group with generators [(1,2,3)]
返回由生成的置换组 (1,2,3) . 正如所料，这是一组3阶。注意，我们并没有得到一组实际的陪集，而是得到了一组 同构的 到因子组。
简单组¶
很容易检查一个组是否是任何正规子群的无效。命令：
sage: AlternatingGroup(5).is_simple()
True
sage: AlternatingGroup(4).is_simple()
False
印刷品 True 然后 False .
构图系列¶
对于任何一个群体，都很容易得到一个作文系列。算法中有一个随机因素，所以你可能不会总是得到相同的结果。（但是根据Jordan-Hölder定理，因子组的列表是唯一的。）此外，生成的子群有时有比必要的更多的生成器，因此您可能需要通过检查诸如其顺序之类的属性来仔细“研究”每个子群。
一个有趣的例子是：
DihedralGroup(105).composition_series()
输出将是5个子组的列表 D_{{105}} ，每个都是其前身的正规子群。
其他几个系列也是可能的，比如派生系列。使用制表符完成查看可能性。
共轭¶
给一组 G ，我们可以定义一个关系 sim 在 G 签字人：代表 a,b in G ， a sim b 当且仅当存在一个元素时 g in G 这样的话 gag^{{-1}} = b .
由于这是一个等价关系，因此 G 变成等价类。对于这个非常重要的关系，这些类被称为“共轭类”。假设 G 是一个置换群 G.conjugacy_classes_representatives() 将返回$G$的元素列表，每个共轭类一个。
给定一个元素 g in G 的“扶正器” g 是布景吗 C(g) = {{h in G mid hgh^{{-1}} = g}} ，它是 G . 一个定理告诉我们，每个共轭类的大小是群的阶数除以该类元素的中心化子的阶数。用下面的代码，我们可以确定5个符号上全对称群的共轭类的大小：
sage: G = SymmetricGroup(5)
sage: group_order = G.order()
sage: reps = G.conjugacy_classes_representatives()
sage: class_sizes = []
sage: for g in reps:
....: class_sizes.append(group_order / G.centralizer(g).order())
...
sage: class_sizes
[1, 10, 15, 20, 20, 30, 24]
这应该会产生列表 [1, 10, 15, 20, 20, 30, 24] 你可以把总数查到120，组的顺序。您可以通过计算组中的元素来生成此列表 S_5 具有相同的循环结构（这将需要一些简单的组合参数）。
Sylow子群¶
Sylow定理断言某些子群的存在性。例如，如果 p 是一个质数，而且 p^r 分组的次序 G 然后 G 必须有顺序的子组 p^r . 可以在 conjugacy_classes_subgroups() 通过检查产生的子组的顺序来命令。这个 map() 命令是一种快速的方法。7个符号的对称群， S_7 ，有秩序 7! = 5040 可被除 2^4 = 16 . 让我们找一个关于4个16阶符号的置换子群的例子：
sage: G = SymmetricGroup(7)
sage: subgroups = G.conjugacy_classes_subgroups()
sage: list(map(order, subgroups))
[1, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8, 8, 8, 9, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 14, 16, 18, 18, 18, 20, 20, 20, 21, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 36, 36, 36, 36, 40, 42, 48, 48, 48, 60, 60, 72, 72, 72, 72, 120, 120, 120, 120, 144, 168, 240, 360, 720, 2520, 5040]
这个 map(order, subgroups) 命令将应用 order() 作用于列表中的每个子组 subgroups . 因此，输出是许多子群的顺序的大列表（准确地说是96）。如果你仔细计算，你会发现第49个子组的顺序是16。您可以将此组引用为 subgroups[48] （记住计数从零开始）。
如果 p^r 是的最高权力 p 分序 G ，然后是序的子群 p^r 被称为“西尔洛” p -“子群。”Sylow的定理也说任何两个Sylow p -子群是共轭的，因此 conjugacy_classes_subgroups() 应该只包含每个Sylow p -分组一次。但是有一个更简单的方法， sylow_subgroup(p) 将返回一个。请注意，命令的参数只是质数$p$，而不是全幂 p^r . 未使用质数将生成一条信息性错误消息。
作为置换群的小阶群¶
我们在这里列出所有阶数小于16的群的结构，作为置换群。
---------------------------------------------------------------------------------------------
Size Construction Notes
---------------------------------------------------------------------------------------------
1 SymmetricGroup(1) Trivial
2 SymmetricGroup(2) Also CyclicPermutationGroup(2)
3 CyclicPermutationGroup(3) Prime order
4 CyclicPermutationGroup(4) Cyclic
4 KleinFourGroup() Abelian, non-cyclic
5 CyclicPermutationGroup(5) Prime order
6 CyclicPermutationGroup(6) Cyclic
6 SymmetricGroup(3) Non-abelian, also DihedralGroup(3)
7 CyclicPermutationGroup(7) Prime order
8 CyclicPermutationGroup(8) Cyclic
8 D1 = CyclicPermutationGroup(4)
D2 = CyclicPermutationGroup(2)
G = direct_product_permgroups([D1,D2]) Abelian, non-cyclic
8 D1 = CyclicPermutationGroup(2)
D2 = CyclicPermutationGroup(2)
D3 = CyclicPermutationGroup(2)
G = direct_product_permgroups([D1,D2,D3]) Abelian, non-cyclic
8 DihedralGroup(4) Non-abelian
8 QuaternionGroup() Quaternions, also DiCyclicGroup(2)
9 CyclicPermutationGroup(9) Cyclic
9 D1 = CyclicPermutationGroup(3)
D2 = CyclicPermutationGroup(3)
G = direct_product_permgroups([D1,D2]) Abelian, non-cyclic
10 CyclicPermutationGroup(10) Cyclic
10 DihedralGroup(5) Non-abelian
11 CyclicPermutationGroup(11) Prime order
12 CyclicPermutationGroup(12) Cyclic
12 D1 = CyclicPermutationGroup(6)
D2 = CyclicPermutationGroup(2)
G = direct_product_permgroups([D1,D2]) Abelian, non-cyclic
12 DihedralGroup(6) Non-abelian
12 AlternatingGroup(4) Non-abelian, symmetries of tetrahedron
12 DiCyclicGroup(3) Non-abelian
Also semi-direct product $Z_3 \rtimes Z_4$
13 CyclicPermutationGroup(13) Prime order
14 CyclicPermutationGroup(14) Cyclic
14 DihedralGroup(7) Non-abelian
15 CyclicPermutationGroup(15) Cyclic
----------------------------------------------------------------------------------------------