有限群共轭类的计算

有限群表示论的一些基本定理：
1、有限群的不同的（非等价的）不可约表示的个数是有限的，并且等于这个群的共轭元素类的个数。

1a、只有有限多不可约表示，它的数目正好等于有限群G的共轭类的数目。

1b、G的不可约表示的个数（确切到同构）等于G的共轭类的个数。
G的两个元素t和t'说是共轭的，如果存在s∈G使得t'=sts^(-1)；这是一个等价关系，这个关系将G划分成类（也叫做共轭类）。

——群G的共轭类个数k是G的不变量，G是Abel群当且仅当k=|G|

——群G的共轭类个数与群G的同阶元个数分布是G的两个不变量，同阶元之间不一定共轭

2、不可约表示的阶数必然是群的因数，而且正则表示等于所有不可约表示的和，其中每一个不可约表示重复出现的次数恰好等于其阶数。

3、有限群的阶数n与不可约表示阶数n_1,n_2,…n_k之间的下面有趣的关系式：n=∑[i=1->k](n_i)^2。n_1=1。

3a、有限群不等价不可约表示维数平方和等于群的阶数∑[j](m_j)^2=g

4、每个有限群G都有一个正则表示，维数是有限群G的阶|G|。

5、线性无关定理：G在K里的不同特征标σ_1,…, σ_n总是线性无关的。

6、下列性质是等价的：a、G是一个Abel群。b、G的一切不可约表示都是一级的。

6a、有限可换群每一个元素组成一个共轭元素类。因此，k=n，n_1=n_2=…=n_k=1，即这样群的所有不可约表示都是一阶的，而且不可约表示的个数等于群的阶数。

上面定理所用到的一些基本定义：

定义1：若行列式不为零的m*m矩阵集合构成的群D(G)与给定群G同构或同态，则D(G)称为群G的一个m维线性表示，简称表示（representation）。

定义1a：群G的一个n阶表示是G到n阶非退化矩阵群里的一个同态映像。一个群G在一个域K上的向量空间V上的线性表示是G到V的自同构群GL(V)中的一个同态ρ:G->GL(V)。
群G的1阶表示是这样的对应：对于G的每一元素，对应着一个复数，而且，群的两个元素的乘积对应着与它们对应的复数的乘积。

线性表示不仅计算比较方便，而且最重要的是它保持群的结构，也就是对于g_1,g_2∈G，总有ρ(g_1)ρ(g_2)= ρ(g_1g_2)。
一个线性表示ρ:G->GL(V)称为完全可约表示，如每个不变子空间U{<}V都有一个不变补空间W，使V=U(+)W。

设G是一个群，K是一个域，G在K里的特征标就是从G到K的乘法群里的同态。
对于特征标σ，τ，乘积στ定义为στ(x)= σ(x)τ(x)，它仍是特征标。G在K里的特征标关于此乘法构成一个Abel群G’，称为G在K里的特征标群。

历史背景、跨学科、跨数学分支联系：

有限群的（复）表示理论起源于19世纪末期Frobenius的工作。在20世纪30年代交换代数产生之后，群表示论逐渐采用模论的语言。数论中采用表示论可以上溯到狄利克雷甚至高斯。二次剩余的勒让德符号，高斯和以及狄利克雷L-函数L(s,χ)中使用的模m狄利克雷特征就是有限Abel群(Z/mZ)^*的特征（一次表示）。他们在研究高斯和以及L(s,χ)的性质中均使用了特征的正交关系。Abel群G的每一共轭类只含一个元素，也就是说，G上每一个函数都是类函数。这种群的线性表示特别简单。

可换群的不可约表示也叫做群的指标【标准中文翻译为特征标】。
对于非可换群的每一表示，其指标【特征标】是指组成这个表示的矩阵的迹（即矩阵对角元素的和）的集合。矩阵的迹Trρ(g)称为表示的特征标。
有限群的指标【特征标】具有很好的性质和关系。
群的表示和指标【特征标】的研究以有兴趣的一般结果丰富了群论，并且这些结果在近代理论物理中找到了宽广的应用。

以上定义、定理、历史背景构成完整的群表示理论内容。

D_4：Con(D_4)=5,每个共轭类的长度=[1,1,2,2,2]
C_8：Con(C_8)=8,每个共轭类的长度=[1,1,1,1,1,1,1,1]
Q_8：Con(Q_8)=5,每个共轭类的长度=[1,1,2,2,2]
GAP4[16,3]：Con(GAP4[16,3])=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
GAP4[16,4]：Con(GAP4[16,4])=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
M_16：Con(M_16)=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
D_8：Con(D_8)=7,每个共轭类的长度=[1,1,2,2,2,4,4]
QD_16：Con(QD_16)=7,每个共轭类的长度=[1,1,2,2,2,4,4]
Q_16：Con(Q_16)=7,每个共轭类的长度=[1,1,2,2,2,4,4]
D_4×C_2：Con(D_4×C_2)=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
GAP4[16,12]：Con(GAP4[16,12])=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
GAP4[16,13]：Con(GAP4[16,13])=10,每个共轭类的长度=[1,1,1,1,2,2,2,2,2,2]
D_9：Con(D_9)=6,每个共轭类的长度=[1,2,2,2,2,9]
GAP4[24,1]：Con(GAP4[24,1])=12,每个共轭类的长度=[1,1,1,1,2,2,2,2,3,3,3,3]
SL(2,3)：Con(SL(2,3))=7,每个共轭类的长度=[1,1,4,4,4,4,6]
GAP4[24,4]：Con(GAP4[24,4])=9,每个共轭类的长度=[1,1,2,2,2,2,2,6,6]
C_4×S_3：Con(C_4×S_3)=12,每个共轭类的长度=[1,1,1,1,2,2,2,2,3,3,3,3]
D_12：Con(D_12)=9,每个共轭类的长度=[1,1,2,2,2,2,2,6,6]
Q_12×C_2：Con(Q_12×C_2)=12,每个共轭类的长度=[1,1,1,1,2,2,2,2,3,3,3,3]
GAP4[24,8]：Con(GAP4[24,8])=9,每个共轭类的长度=[1,1,2,2,2,2,2,6,6]
C_3×D_4：Con(C_3×D_4)=15,每个共轭类的长度=[1,1,1,1,1,1,2,2,2,2,2,2,2,2,2]
C_3×Q_8：Con(C_3×Q_8)=15,每个共轭类的长度=[1,1,1,1,1,1,2,2,2,2,2,2,2,2,2]
S_4：Con(S_4)=5,每个共轭类的长度=[1,3,6,6,8]
C_2×A_4：Con(C_2×A_4)=8,每个共轭类的长度=[1,1,3,3,4,4,4,4]
C_2×C_2×S_3：Con(C_2×C_2×S_3)=12,每个共轭类的长度=[1,1,1,1,2,2,2,2,3,3,3,3]

// 定义：给定群G，对G中的两个元a，b，若存在G中的某个元g，使得g^-1ag=b，就称元素a，b在G中共轭，记为a~b。
bool IsConjugacy(const vector<vector<int>> &vvG,int a,int b)
{
   int N=vvG.size();
   for(int i=0;i<N;i++)
   {
       int ai=vvG[a][i]-1;
       int ib=vvG[i][b]-1;
       if(ai==ib)
           return true;
   }
   return false;
}

vector<int> ConjugacyClasses(const vector<vector<int>> &vvG,int a)
{
   vector<int> ret;
   int N=vvG.size();
   for(int i=0;i<N;i++)
   {
       bool bCon=IsConjugacy(vvG,a,i);
       if(bCon)
           ret.push_back(i);
   }
   return ret;
}

vector<vector<int>> ConjugacyClasses(const vector<vector<int>> &vvG)
{
   vector<vector<int>> vv;
   int N=vvG.size();
   for(int i=0;i<N;i++)
   {
       vector<int> v=ConjugacyClasses(vvG,i);
       vv.push_back(v);
   }
   sort(vv.begin(),vv.end());
   vv.erase(unique(vv.begin(),vv.end()),vv.end());
   return vv;
}

//G表示有限群，Con(G)表示G的共轭类个数，o(a)表示元素a的阶。
//群的共轭类个数、长度
vector<int> ConjugacyClasses(int *R,int N,int delt=1)
{
   vector<int> ret;
   if(!IsGroup(R,N,delt))
       return ret;
// // 共轭类数为1的有限群，只能是单位元群{e}。
   //if(N==1)
   //   return 1;
// // 共轭类数为2的有限群，只能是2阶循环群。
   //if(N==2)
   //   return 2;
   vector<vector<int> > vvG=Arr2ToVec2(R,N,delt);
   vector<vector<int> > vv=ConjugacyClasses(vvG);
   int len=vv.size();
   for(int i=0;i<len;i++)
       ret.push_back(vv[i].size());
   sort(ret.begin(),ret.end());
   return ret;
}

{
int *Arr[]={g_D4,&g_C8Mul[0][0],&g_Q8Mul[0][0],g_16_3,g_16_4,g_M16,g_D8,g_QD16,g_Q16,g_D4C2,g_16_12,g_16_13,g_D9,g_24_1,g_24_3,g_24_4,g_C4S3,g_D12,g_Q12C2,g_24_8,g_C3D4,g_C3Q8,g_S4,g_C2A4,g_C2C2S3};
int Nrr[]={8,8,8,16,16,16,16,16,16,16,16,16,18,24,24,24,24,24,24,24,24,24,24,24,24};
int Drr[]={0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
const char *szName[]={"D_4","C_8","Q_8","GAP4[16,3]","GAP4[16,4]","M_16","D_8","QD_16","Q_16","D_4×C_2","GAP4[16,12]","GAP4[16,13]","D_9","GAP4[24,1]","SL(2,3)","GAP4[24,4]","C_4×S_3","D_12","Q_12×C_2","GAP4[24,8]","C_3×D_4","C_3×Q_8","S_4","C_2×A_4","C_2×C_2×S_3"};
int n=sizeof(Arr)/sizeof(Arr[0]);
for(int i=0;i<n;i++)
{
int *A=Arr[i];
int N=Nrr[i];
vector<int> v=ConjugacyClasses(A,N,Drr[i]);
string str="[";
for(int j=0;j<v.size();j++)
{
char sz[20]={0};
sprintf(sz,"%d,",v[j]);
str+=sz;
}
str.pop_back();
str+="]";
printf("%s：Con(%s)=%d,每个共轭类的长度=%s\n",szName[i],szName[i],v.size(),str.c_str());
}
system("pause");
return 0;
}

编号 GAP 序列号性质指数中心 G/[G,G] 共轭类子群子群类正规子群
1 1 循环 8 C8 C8 8 -- -- --
2 2 阿贝尔 4 C2×C4 C2×C4 8 -- -- --
3 5 阿贝尔 2 C23 C23 8 -- -- --
4 4 幂零 4 C2 C22 5 6 6 6
5 3 幂零 4 C2 C22 5 10 8 6
编号 GAP 序列号性质指数中心 G/[G,G] 共轭类子群子群类正规子群
1 2 循环 18 C2×C9 C2×C9 18 -- -- --
2 5 阿贝尔 6 C2×C32 C2×C32 18 -- -- --
3 1 两面体 18 1 C2 6 16 6 4
4 4 可解 6 1 C2 6 28 12 7
5 3 可解 6 C3 C2×C3 9 14 9 6
G=D9由 3 个元素 {a1, a2, a3} 生成, 具有相应的阶 ( 2, 9, 3 ). 它也由 2 个元素 {a1, a2} 生成, 相应的阶为 ( 2, 9).
G 有 6 个元素共轭类, 16 个子群在 6 个子群共轭类里, 其中 4 是正规子群.
G=G18_5由 3 个元素 {a1, a2, a3} 生成, 具有相应的阶 ( 2, 3, 3 ).
G 有 6 个元素共轭类, 28 个子群在 12 个子群共轭类里, 其中 7 是正规子群.
G=D3C3由 3 个元素 {a1, a2, a3} 生成, 具有相应的阶 ( 2, 3, 3 ). 它也由 2 个元素 {a3, a2 a1} 生成, 相应的阶为 ( 3, 6).
G 有 9 个元素共轭类, 14 个子群在 9 个子群共轭类里, 其中 6 是正规子群.

14种16阶群
编号 GAP 序列号性质指数中心 G/[G,G] 共轭类子群子群类正规子群
1 1 循环 16 C16 C16 16 -- -- --
2 5 阿贝尔 8 C2×C8 C2×C8 16 -- -- --
3 2 阿贝尔 4 C42 C42 16 -- -- --
4 10 阿贝尔 4 C22×C4 C22×C4 16 -- -- --
5 14 阿贝尔 2 C24 C24 16 -- -- --
6 9 幂零 8 C2 C22 7 11 9 7
7 8 幂零 8 C2 C22 7 15 10 7
8 7 幂零 8 C2 C22 7 19 11 7
9 6 幂零 8 C4 C2×C4 10 11 10 9
10 13 幂零 4 C4 C23 10 23 20 17
11 4 幂零 4 C22 C2×C4 10 15 13 11
12 3 幂零 4 C22 C2×C4 10 23 17 11
13 12 幂零 4 C22 C23 10 19 19 19
14 11 幂零 4 C22 C23 10 35 27 19
15种24阶群
编号 GAP 序列号性质指数中心 G/[G,G] 共轭类子群子群类正规子群
1 2 循环 24 C3×C8 C3×C8 24 -- -- --
2 9 阿贝尔 12 C2×C3×C4 C2×C3×C4 24 -- -- --
3 15 阿贝尔 6 C23×C3 C23×C3 24 -- -- --
4 6 两面体 12 C2 C22 9 34 16 9
5 11 幂零 12 C2×C3 C22×C3 15 12 12 12
6 10 幂零 12 C2×C3 C22×C3 15 20 16 12
7 1 可解 24 C4 C8 12 10 8 7
8 12 可解 12 1 C2 5 30 11 4
9 3 可解 12 C2 C3 7 15 7 4
10 4 可解 12 C2 C22 9 18 12 9
11 8 可解 12 C2 C22 9 30 16 9
12 5 可解 12 C4 C2×C4 12 26 16 11
13 7 可解 12 C22 C2×C4 12 22 16 13
14 13 可解 6 C2 C2×C3 8 26 12 6
15 14 可解 6 C22 C23 12 54 32 21

共轭元素的定义：对于群G中的任意元素s，元素g和f=sgs^(-1)定义为互共轭元素，记为g~f。
自轭性: 任何元素与其本身共轭, 即g~g
对称性: 若g~f, 则f~g.
传递性: 若g~f_1,g~f_2,则f_1~f_2。
类的定义：群G中所有相互共轭的元素构成的集合称为群G的一个类。根据共轭关系的性质，群G的一个类中的元素可由该类中任一元素生成, 即f类={f'|f'=sfs^(-1),s∈G}，s取遍群G所有元素，重复元素sfs^(-1)只取一次。根据共轭的传递性可证: 两个不同的类没有公共元素。
定理：有限群的阶是每一个类的元素个数的整数倍。
E.Landau定理（Frobenius猜想）：共轭类数为n的有限群，在同构意义下是有限的。
定理：有限群为交换群的充要条件是Con(G)=|G|。
定理：共轭类数为1的有限群，只能是单位元群C_1。共轭类数为2的有限群，只能是2阶循环群C_2。共轭类数为3的有限群，是可解群，是3阶循环群或者6阶群。
Abel群G的每一共轭类只含一个元素，也就是说，G上每一个函数都是类函数。这种群的线性表示特别简单。
定理9：下列性质是等价的：
1.G是一个Abel群。
2.G的一切不可约表示都是一级的。
定理7：G的不可约表示的个数（确切到同构）等于G的共轭类的个数。
G的两个元素t和t'说是共轭的，如果存在s∈G使得t'=sts^(-1)；这是一个等价关系，这个关系将G划分成类（也叫做共轭类）。
——群G的共轭类个数k是G的不变量，G是Abel群当且仅当k=|G|
——群G的共轭类个数与群G的同阶元个数分布是G的两个不变量，同阶元之间不一定共轭

20151006：GAP求有限群的共轭类个数以及每个共轭类的长度
gap> n:=18;;len:=NumberSmallGroups(n);;for i in [1..len] do Print(Size(ConjugacyClasses(SmallGroup(n,i))),","); od;
6,18,9,6,18,
gap> n:=8;;len:=NumberSmallGroups(n);;for i in [1..len] do Print(Size(ConjugacyClasses(SmallGroup(n,i))),","); od;
8,8,5,5,8,
gap> G:=SmallGroup(8,3);IdGroup(G);cl:=ConjugacyClasses(G);len:=Size(cl);for i in [1..len] do Print(Size(cl[i]),","); od;Print("\n");for i in [1..len] do Print(IdGroup(Centralizer(cl[i])),","); od;
<pc group of size 8 with 3 generators>
[ 8, 3 ]
[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G ]
5
1,2,2,1,2,
[ 8, 3 ],[ 4, 2 ],[ 4, 2 ],[ 8, 3 ],[ 4, 1 ],
gap> G:=SmallGroup(8,4);IdGroup(G);cl:=ConjugacyClasses(G);len:=Size(cl);for i in [1..len] do Print(Size(cl[i]),","); od;Print("\n");for i in [1..len] do Print(IdGroup(Centralizer(cl[i])),","); od;
<pc group of size 8 with 3 generators>
[ 8, 4 ]
[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G ]
5
1,2,2,1,2,
[ 8, 4 ],[ 4, 1 ],[ 4, 1 ],[ 8, 4 ],[ 4, 1 ],
gap> G:=SmallGroup(8,1);IdGroup(G);cl:=ConjugacyClasses(G);len:=Size(cl);for i in [1..len] do Print(Size(cl[i]),","); od;Print("\n");for i in [1..len] do Print(IdGroup(Centralizer(cl[i])),","); od;
<pc group of size 8 with 3 generators>
[ 8, 1 ]
[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G, f1*f3^G, f2*f3^G, f1*f2*f3^G ]
8
1,1,1,1,1,1,1,1,
[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],[ 8, 1 ],
gap> G:=SmallGroup(8,2);IdGroup(G);cl:=ConjugacyClasses(G);len:=Size(cl);for i in [1..len] do Print(Size(cl[i]),","); od;Print("\n");for i in [1..len] do Print(IdGroup(Centralizer(cl[i])),","); od;
<pc group of size 8 with 3 generators>
[ 8, 2 ]
[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G, f1*f3^G, f2*f3^G, f1*f2*f3^G ]
8
1,1,1,1,1,1,1,1,
[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],[ 8, 2 ],
gap> G:=SmallGroup(8,5);IdGroup(G);cl:=ConjugacyClasses(G);len:=Size(cl);for i in [1..len] do Print(Size(cl[i]),","); od;Print("\n");for i in [1..len] do Print(IdGroup(Centralizer(cl[i])),","); od;
<pc group of size 8 with 3 generators>
[ 8, 5 ]
[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G, f1*f3^G, f2*f3^G, f1*f2*f3^G ]
8
1,1,1,1,1,1,1,1,
[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],[ 8, 5 ],