版权申明：本文为博主窗户(Colin Cai)原创，欢迎转帖。如要转贴，必须注明原文网址
https://www.cnblogs.com/Colin-Cai/p/18791060.html
作者：窗户
QQ/微信：6679072
E-mail：[email protected]本节在上一节的基础上，解释循环群，Abel群，群同构，直积等概念，最终推导出给定阶数的所有Abel群结构。
循环群
循环群是最简单的群，n阶循环群为\\{0,1,2...n-1\\}，符号记作Z_n，在此基础上定义乘法：
a \\cdot b = (a+b) \\mod n
这个是不是看上去很像加法？嗯，叫加法还是叫乘法还是叫其他什么都不重要，性质才重要。
此处的这个运算是可以交换的，也就是
a \\cdot b = b \\cdot a
在不引起误解的情况下，我们习惯上把这个称之为加法。
符号上，既然叫了加法，我们用\\oplus来代替\\cdot。
循环群就是1生成的群，
1 \\oplus 1 = 2
2 \\oplus 1 = 3
...
(n-1) \\oplus 1 = 0
在符号不会发生混乱的情况下，我们就用a+b来表示加法。
加了一圈，得到了循环群里所有的元素，总共n个1相加得到0，显然0是幺元。
对于一个群里的元素a，如果n个a相乘(或相加)得到幺元，且n是满足这一点的最小正整数，则称n是a的周期。
注意，周期这个术语是对于所有的群，并非只对于循环群。
此处，n是1的周期。
其实，循环群的定义就是可以由一个元(也就是1)生成的群。
对于有限循环群，那么就是存在某个元的周期等于阶数的群。
无限循环群则不是，Z覆盖了所有整数，其群加法就是整数加法，幺元为0，生成元为1。
对于这个生成元，或许有人会有疑问，无论多少个1加在一起也不会是负数啊，怎么可能所有的整数都由1生成呢。
在此，我要声明一下，逆元可以直接生成，所以-1可以由1生成，从而所有整数也都能生成了，此规则记住即可。
容易证明，对于Z_n，任何小于n的正整数m，在该循环群里的周期为\[m,n\]/m，此处\[m,n\]为最小公倍数。
所以，所有与n互质且小于n的正整数都可以是Z_n的生成元。
Abel群
Abel群即交换群，也就是满足乘法交换律的群。
也就是\
\\forall a,b \\in G, a \\cdot b = b \\cdot a
前面提到的循环群就是一种Abel群，那么，有不是循环群的Abel群吗？
我们来看2阶循环群Z_2
然后建立一个有4个元素的群
\\{(0,0),(0,1),(1,0),(1,1)\\}
其中乘法如下定义
(a,b) \\cdot (c,d) = (a \\cdot c, b \\cdot d)
可以得知，(0,0)是该群的幺元，
(a,b) \\cdot (0,0) = (a \\cdot 0, b \\cdot 0) = (a,b) = (0 \\cdot a, 0 \\cdot b) = (0,0) \\cdot (a, b)
每个元的逆元是自身(源于Z_2的每个元逆元为自身)，实际上
(a,b) \\cdot (a,b) = (a \\cdot a, b \\cdot b) = (0,0)
很显然也满足乘法交换律
(a,b) \\cdot (c,d) = (a \\cdot c, b \\cdot d) = (c \\cdot a, d \\cdot b) = (c,d) \\cdot (a,b)
所以这是一个Abel群。
然而，4阶循环群Z_4里的1的周期为4，而这个群里除幺元外所有的元素周期都为2，显然不是循环群。
那么，有非交换群吗？
有的，我们给出以下6元群。
\\{e,y,y\^2,x,xy,xy\^2\\}
其中，
x\^2=y\^3=e
yx=xy\^2
生成乘法表如下
\begin{matrix}
\cdot& e & y & y^2 & x & xy & xy^2 \\
e & e & y & y^2 & x & xy & xy^2 \\
y & y & y^2 & e & xy^2 & x & xy\\
y^2 & y^2 & e & y & xy & xy^2 & x\\
x & x & xy & xy^2 & e & y & y^2\\
xy & xy & xy^2 & x & y^2 & e & y\\
xy^2 & xy^2 & x & xy & y & y^2 & e\\
\end{matrix}
可以验证，上面是一个群,
另外，这个乘法表的方阵并不是对称方阵，也就是，它并不是Abel群。
其实，这个群是阶数最小的非交换群，它是一个二面体群 ，记作D_3，所谓D_n，是正n边形的所有对称映射 构成的群,D_3就是正三角形的对称映射群。
对称映射群，这个名字一下子不好理解，那就换个名字，就叫全等群。
正n边形和自身有多少种不同的全等？
顺时针方向：
S_{A_1,A_2,...A_n} \\cong S_{A_1,A_2,...A_n}
S_{A_1,A_2,...A_n} \\cong S_{A_2,A_3,...A_n,A_1}
...
S_{A_1,A_2,...A_n} \\cong S_{A_n,A_1,...A_{n-1}}
逆时针方向：
S_{A_1,A_2,...A_n} \\cong S_{A_1,A_n,...A_2}
S_{A_1,A_2,...A_n} \\cong S_{A_2,A_1,A_n...A_3}
...
S_{A_1,A_2,...A_n} \\cong S_{A_n,A_{n-1},...A_1}
总共2n个全等。
另外，
D_3 \\cong S_3
S_3是3阶对称群，也就是3个元素所有的置换组成的群。
群同构
一般群论教材里会先讲群同态，再把群同构当成群同态的一种，其中可以引入同态定理，但那是一本正经的讲法。
我这里只是讲个大致，所以同态我直接滤过了。
其实同构才是拍下脑袋就能明白的东西，因为它实在太自然了。
同构同构，顾名思义，就是同样的结构。研究一个群，代表所有与之同构的群的性质。
先看看数学符号，群a和群b同构记作a \\cong b
即便没学过高等数学的中学生，也会知道这个符号在平面几何、立体几何里指图形的全等，也就是性质完全一模一样。
我们以数学的直觉，来想想什么样的两个群称为同构呢。
群有两个东西，一个是里面的元素集合，一个是构建在元素集合上的二元运算。
我们甚至可以超越群的限制，想象一下什么叫\
其中，f_1是集合G_1上的二元运算，f_2是集合G_2上的二元运算，
不一定需要构成群。
那么，应该是在一一对应下两者的所有表现一模一样。那么应该是：
对于一一对应f:G_1\\rightarrow G_2
\\forall a, b \\in G_1:f(a\\cdot _{1}b)=f(a)\\cdot _{2} f(b)
上一章里，求出的群有很多同构，那么我们如何让同构的群只出一个即可呢？
最简单的方法，就是构造一个过滤条件，每当新出一个群，就看看是否和之前出过的群同构，
还是用方阵(array下用一维来模拟二维)来代表二元运算，以下函数用来判断同构，op1/op2则是代表二元运算的方阵。
import array
import itertools as it
def is_isomp(s, op1, op2):
n = len(s)
make_mul = lambda op : lambda a, b : op[a * n + b]
#将矩阵op1和op2转化成真正的函数
mul_op1 = make_mul(op1)
mul_op2 = make_mul(op2)
#将排列转换成一一对应
f = lambda n : s[n]
#遍历所有的乘法
for a, b in it.product(range(n), range(n)):
#如果发现不满足,当然不是同构
if f(mul_op1(a, b)) != mul_op2(f(a), f(b)):
return False
#如果发现当前一一对应满足同构,那么就返回构成同构
return True
def isomp(n, op1, op2):
#遍历所有的一一对应,所有的一一对应其实和所有的n全排序一一对应
for s in it.permutations(range(n)):
if is_isomp(s, op1, op2):
return True
return False我们看看之前D_3在上一节里表示乘法的array该是什么
首先，我们让e,y,y\^2,x,xy,xy\^2分别对应0,1,2,3,4,5，那么乘法表矩阵应该是
\begin{matrix}
0 & 1 & 2 & 3 & 4 & 5 \\
1 & 2 & 0 & 5 & 3 & 4\\
2 & 0 & 1 & 4 & 5 & 3\\
3 & 4 & 5 & 0 & 1 & 2\\
4 & 5 & 3 & 2 & 0 & 1\\
5 & 3 & 4 & 1 & 2 & 0\\
\end{matrix}
显然任何一个群，在恒等映射下一定是同构的，这种同构是平凡的，也就是没啥大的意义。
我们用程序搜一下:
op = array.array('i', [0, 1, 2, 3, 4, 5,
1, 2, 0, 5, 3, 4,
2, 0, 1, 4, 5, 3,
3, 4, 5, 0, 1, 2,
4, 5, 3, 2, 0, 1,
5, 3, 4, 1, 2, 0])
for s in it.permutations(range(6)):
if is_isomp(s, op, op):
print(s)得到所有构成同构的一一对应：
(0, 1, 2, 3, 4, 5)
(0, 1, 2, 4, 5, 3)
(0, 1, 2, 5, 3, 4)
(0, 2, 1, 3, 5, 4)
(0, 2, 1, 4, 3, 5)
(0, 2, 1, 5, 4, 3)
这种同构是一个群自己到自己的映射，称为自同构。
一个群所有的自同构其实也构成一个群，称为自同构群。
D_3和D_3的自同构群(可记作Aut(D_3))恰好同构：
op = array.array('i', [0, 1, 2, 3, 4, 5,
1, 2, 0, 5, 3, 4,
2, 0, 1, 4, 5, 3,
3, 4, 5, 0, 1, 2,
4, 5, 3, 2, 0, 1,
5, 3, 4, 1, 2, 0])
#ss装下所有的D3上的自同构置换
ss = []
for s in it.permutations(range(6)):
if is_isomp(s, op, op):
ss.append(list(s))
#两个置换的乘积
def mul(a, b):
r = [0] * len(a)
for i in range(len(b)):
r[i] = a[b[i]]
return r
#op_aut是D3自同构群的乘法表
op_aut = array.array('i', [0] * 36)
for i, a in enumerate(ss):
for j, b in enumerate(ss):
c = mul(a, b)
for k, s in enumerate(ss):
if c == s:
op_aut[i * 6 + j] = k
break
#以下判断D3和D3自同构群两者同构与否
print(isomp(6, op, op_aut))不过关于自同构群属于题外话，不深入讲了。
子群
如果一个群内部的一部分元素在该群的乘法下也构成一个群，那么这个群则叫子群(subgroup)。
很明显，子群中必然包含原群的幺元作为幺元。
比如之前的二面体群D_3中，
\\{e,x\\}
\\{e,y,y\^2\\}
\\{e,xy\\}
\\{e,xy\^2\\}
在原乘法下，都是D_3的子群，注意，这些群都是循环群。
另外，\\{e\\}和\\{e,y,y\^2,x,xy,xy\^2\\}也是D_3的子群，只是这是每个群都有的，也就是平凡的，没什么特殊意义。
对于n阶循环群，如果m是n的正约数，则该循环群有m阶子群，
实际上，n/m生成的群，就是n阶循环群的m阶子群，当然子群也是循环群。
直积
这是一种用群构建群的方式。
如果\
那么集合G=\\{(a,b)\|a \\in G_1,b \\in G_2\\}
配合以下乘法
(a_1,b_1) \\cdot (a_2,b_2)=(a_{1}\\cdot_{1} a_2,b_{1}\\cdot_{2}b_2)
我们来看一下它为什么是一个群。
首先，对于任意G下\
(a,b)\\cdot(c,d) \\cdot (e,f)
=(a\\cdot_{1}c,b\\cdot_{2}d)\\cdot(e,f)
=(a\\cdot_{1}c\\cdot_{1}e,b\\cdot_{2}d\\cdot_{2}f)
=(a\\cdot_{1}(c\\cdot_{1}e),b\\cdot_{2}(d\\cdot_{2}f))
=(a,b)\\cdot(c\\cdot_{1}e,d\\cdot_{2}f)
=(a,b)\\cdot((c,d)\\cdot(e,f))
满足结合律，
对于任意G下\
假设e_1和e_2是原群的幺元,
(a,b)\\cdot (e_1,e_2) = (a,b) = (e_1,e_2)\\cdot (a,b)
所以(e_1,e_2)是幺元,
(a,b)\\cdot (a\^{-1},b\^{-1}) = (e_1,e_2) = (a\^{-1},b\^{-1}) \\cdot (a,b)
所以(a\^{-1},b\^{-1})是逆元，
根据群的定义，这个新的代数结构的确是群，称为两个群的外直积 。
为了研究群的内部结构，我们引入内直积，这样直积前的两个群都是最终得到的群的子集。
如果\
且G_1 \\cap G_2 = \\{e\\}
那么，集合G=\\{a\\cdot b\|a \\in G_1,b\\in G_2\\}满足
a_{1},a_{2} \\in G_{1} \\land b_{1},b_{2} \\in G_{2} \\land a_{1} \\cdot b_{1} = a_{2} \\cdot b_{2} \\Rightarrow a_{1} = a_{2} \\land b_{1} = b_{2}
再加上相应的乘法就是内直积得到的群，
对于乘法，原G_1里的元和原G_2里的元两者乘法可交换，
那么，对于a,c \\in G_1, b,d \\in G_2，
(a\\cdot b) \\cdot (c\\cdot d)
=a\\cdot b \\cdot c \\cdot d
=a\\cdot (b \\cdot c) \\cdot d
=a\\cdot (c \\cdot b) \\cdot d
=a\\cdot c \\cdot b \\cdot d
=(a\\cdot c) \\cdot (b \\cdot d)
外直积和内直积得到的结果实际上是同构的，所以从研究的角度来说，是可以替代的。
我们再回头看看D_3，它也有\\{e,x\\}和\\{e,y,y\^2\\}两个子群，
但它并不是这两个子群的直积，因为第一个群的x和第二个群的y乘法不可交换。
另外，两个Abel群的直积依然是Abel群，这个很容易证明，这一条与本系列所要讨论的Abel群的结构有直接关系。
还是给直积一个符号以便后面叙述吧，记群G_1和群G_2的直积为G_1\\otimes G_2
循环群内直积的条件
我们现在考虑有限Abel群的生成元。
如果从群G中取n个元可以生成G，
暂时记作G=\
因为Abel群满足乘法交换律，那么G中任意的元g都可以写成以下的形式:
g = k_1\*a_1+k_2\*a_2+...k_n\*a_n
其中，k\*a中k是小于a周期的自然数，
意思为k个a相乘(加)的结果。再重申一次，对于Abel群(也就是可交换群)，我们可以把里面的乘法叫加法，所以这里使用加号。
其中，如果存在一组k_1,k_2...k_n
使得k_1\*a_1+k_2\*a_2+...k_n\*a_n = 0
那么k_1\*a_1,k_2\*a_2,...kn\*an必然全为0
在这种情况下，对于任意k_1\*a_1+k_2\*a2+...k_n\*a_n和j_1\*a_1+j_2\*a2+...j_n\*a_n
两者相减为(k_1 - j_1)\*a_1+(k_2-j_2)\*a_2+...(k_n-j_n)\*a_n
相减为0则意味着(k_1 - j_1)\*a_1=0\\land (k_2 - j_2)\*a_2=0 \\land (k_n - j_n)\*a_n=0
根据上面条件，我们发现两者相等只有在各项相等的情况下。
并且本身就是Abel群，两者当然也是乘法可交换的。
从而，G是\
也就是G=\
另外，对于Abel群G=\
如果存在k_1\*a_1,k_2\*a_2,...k_n\*a_n不全为0使得k_1\*a_1+k_2\*a_2+...k_n\*a_n = 0
那么a_1,a_2,...a_n中必然存在一个元可以被其他元线性表出，这其实是线性代数的基本功，回忆一下无关线性向量组相关的知识，再加上联系到此处各个元的周期有限，应该不难证明，此处省略证明留给读者。
于是可以找到少一个元生成整个群。
如此不断剔除多余的生成元下去，最终总可以找到满足开始的条件，也就是无论如何，有限Abel群都可以表示为循环群直积的形式。
循环群直积的标准化
现在我们再来考虑一个例子，
假如一个6元的Abel群我们发现同构于Z_2 \\otimes Z_3
我们用外直积可能更容易理解，
它的六个元分别是
(e,e),(e,b),(e,b\^2),(a,e),(a,b),(a,b\^2)
其中a周期为2，b周期为3
结果发现里面有一个周期为6的元素(a,b)，结果其实它同构于Z_6
我们当然更喜欢直接到位用Z_6就能很清楚的明白它的结构了。
这就意味着我们虽然可以有办法把Abel群表示为循环群的直积，但仍需要进一步化简。
我们考虑Z_m \\otimes Z_n
为了明白起见，我们还是用外直积来理解。
考虑它有两个生成元(a,e)和(e,b)
其中a周期为m，b周期为n
显然，\
另，m和n最大公约数，记作gcd(m,n)。
我们有
lcm(m\*n) = m/gcd(m,n)\*n = n/gcd(m,n)\*m
其中，m/gcd(m,n)和n/gcd(m,n)都是正整数，
又显然，对于其他任何元(k_1\*a,k_2\*b)
lcm(m\*n)\*(k_1\*a,k_2\*b)
=((lcm(m\*n)\*k_1)\*a,(lcm(m\*n)\*k_2)\*b)
=((n/gcd(m,n)\*m\*k_1)\*a,(m/gcd(m,n)\*n\*k_2)\*b)
=(n/gcd(m,n)\*k_1\*(m\*a),m/gcd(m,n)\*k_2\*(n\*b))
=(e,e)
这意味着(a,b)有着整个群里最大的周期。
不难得出，
(m/gcd(m,n)\*a,n/gcd(m,n)\*b)和(a,b)可以作为整个群的生成元
具体证明读者自行去证，提示一下，需要用到以下命题：
对于任意正整数m，n，存在整数p和q，使得
mp+nq=gcd(m,n)
(a,b)周期为lcm(m,n)，
(m/gcd(m,n)\*a,n/gcd(m,n)\*b)周期为gcd(m,n)
所以Z_m \\otimes Z_n \\cong Z_{gcd(m,n)} \\otimes Z_{lcm(m,n)}
注意，lcm(m,n)是整个群最大的周期，并且gcd(m,n)是lcm(m,n)的约数。
另外，对于平凡的直积
Z_1 \\otimes Z_n \\cong Z_n
可以去掉Z_1项
又因为直积满足交换之后依然同构，
于是对于Z_{k_1} \\otimes Z_{k_2} \\otimes ... Z_{k_n}的化简，可以如下这样两层循环进行，可以使得最终为一组循环群的直积，满足左边循环群的阶数是右边循环群阶数的约数。
#最大公约数
def gcd(m, n):
while True:
if n == 0:
return m
m %= n
if m == 0:
return n
n %= m
#最小公倍数
def lcm(m, n):
return m * n // gcd(m, n)
#标准化
def trans(k):
#复制k数组
a = [n for n in k]
length = len(a)
#两轮循环化简
for n in range(length - 1):
for m in range(n + 1, length):
a[n], a[m] = gcd(a[n], a[m]), lcm(a[n], a[m])
#剔除掉1
for i in range(length):
if a[i] != 1:
return a[i:]
return a比如我们想要标准化Z_{6} \\otimes Z_{10} \\otimes Z_{15} \\otimes Z_{20}
simplify([6,10,15, 20]) => [10, 30, 60]
也就是Z_{10} \\otimes Z_{30} \\otimes Z_{60}
以上的结果可以看出，运算到最后，前面的数字是后面数字的约数，并且不存在1，这个表示对于这个群是唯一的。
于是我们就根据此得到给定阶数的Abel群所有的同构。
以72阶Abel群为例，我们分解72为大于1的整数乘积，满足左边是右边的约数，可以穷举出72阶Abel群所有的同构如下：
Z_{72}
Z_2 \\otimes Z_{36}
Z_3 \\otimes Z_{24}
Z_6 \\otimes Z_{12}
Z_2 \\otimes Z_2 \\otimes Z_{18}
Z_2 \\otimes Z_6 \\otimes Z_6
下一节我们设计程序来穷举给定阶数Abel群的所有同构。