D:\go20190906\src\SmallRing>go build IGroup.go
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
# command-line-arguments
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
D:\go20190906\src\SmallRing>IGroup
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
GAP[6,1]=S_3:
1 2 3 4 5 6
2 3 1 6 4 5
3 1 2 5 6 4
4 5 6 1 2 3
5 6 4 3 1 2
6 4 5 2 3 1
羣GAP[6,1]的不變量:N0= [1 3 3 2 2 2] ,bA= 0 ,bC= [] ,Z= [0]
[0 1 2] 是正規子羣
[0 3] 不是正規子羣
GAP[3,1]=C_3:
1 2 3
2 3 1
3 1 2
羣GAP[3,1]的不變量:N0= [1 3 3] ,bA= 1 ,bC= [1 2] ,Z= [0 1 2]
羣GAP[120,34]的不變量:N0= [1 2 2 3 3 2 2 2 3 4 4 3 3 4 2 3 2 4 4 3 3 2 4 2 2 2 2 6 6 2 3 6 4 5 5 4 4 5 3 4 6 5 5 4 4 3 5
6 3 6 4 5 5 4 2 2 3 4 4 3 2 6 4 5 5 6 6 2 5 4 6 5 4 5 3 4 6 5 3 4 2 3 2 4 4 5 2 6 6 5 5 6 6 5 2 4 5 4 4 3 5 6 4 3 3 2 4
2 5 4 6 2 5 6 6 5 5 6 4 2] ,bA= 0 ,bC= [] ,Z= [0]
package main
import "fmt"
func getidx(v *[]int,id int)int{
n:=len(*v)
for i:=0;i<n;i++{
if((*v)[i]==id){
return i
}
}
return -1
}
//接口的定義
type IGroup interface {
printTable()
mul(a,b int)int
size()int
inv(a int)int
}
func printGroup(g IGroup){
n:=g.size()
for i:=0;i<n;i++{
for j:=0;j<n;j++{
ij:=g.mul(i,j)
fmt.Printf("%d ",ij+1)
}
fmt.Printf("\n")
}
}
// 羣元的階
func getGOrder(g IGroup,a int)int{
n:=g.size()
if(a<0||a>=n){
return -1
}
t:=0
for i:=1;i<=n;i++{
t=g.mul(t,a)
if(t==0){
return i
}
}
return -1
}
// 未經排序的羣元階的分佈
func calN0(g IGroup)[]int{
ret:=[]int{}
n:=g.size()
for i:=0;i<n;i++{
ord:=getGOrder(g,i)
ret=append(ret,ord)
}
return ret
}
func issubgroup(g IGroup,v *[]int,id int)bool{
if(getidx(v,id)==-1){
return false
}
n:=len(*v)
// 乘法封閉性
for i:=0;i<n;i++{
for j:=i;j<n;j++{
ij:=g.mul((*v)[i],(*v)[j])
ji:=g.mul((*v)[j],(*v)[i])
if(getidx(v,ij)==-1){
return false
}
if(getidx(v,ji)==-1){
return false
}
}
}
// 有乘法逆元
for i:=0;i<n;i++{
iinv:=g.inv((*v)[i])
if(getidx(v,iinv)==-1){
return false
}
}
// id是乘法單位元
for i:=0;i<n;i++{
if(g.mul(id,(*v)[i])!=(*v)[i] || g.mul((*v)[i],id)!=(*v)[i]){
return false
}
}
return true
}
//0是正規子羣
//1是子羣但不是正規子羣
//2不是子羣
func isnormalsubgroup(g IGroup,v *[]int,id int)int{
if(!issubgroup(g,v,id)){
return 2
}
n:=g.size()
nv:=len(*v)
// 進一步判斷是否是正規子羣
for i:=0;i<n;i++{
for j:=0;j<nv;j++{
ghg1:=g.mul(g.mul(i,(*v)[j]),g.inv(i))
if(getidx(v,ghg1)==-1){
return 1
}
}
}
return 0
}
// bA=1是Abel羣,bA=0不是Abel羣
func calbA(g IGroup)int{
n:=g.size()
// 乘法交換性
for i:=0;i<n;i++{
for j:=i;j<n;j++{
ij:=g.mul(i,j)
ji:=g.mul(j,i)
if(ij!=ji){
return 0
}
}
}
return 1
}
//返回|g|階元的集合，如果集合爲空，則表示g不是循環羣
func calbC(g IGroup)[]int{
ret:=[]int{}
n:=g.size()
for i:=0;i<n;i++{
ord:=getGOrder(g,i)
if(ord==n){
ret=append(ret,i)
}
}
return ret
}
func IsInCenterOfG(g IGroup,j int)bool{
n:=g.size()
for i:=0;i<n;i++{
ij:=g.mul(i,j)
ji:=g.mul(j,i)
if(ij!=ji){
return false
}
}
return true
}
// 計算羣g的中心
func calZ(g IGroup)[]int{
ret:=[]int{}
n:=g.size()
for i:=0;i<n;i++{
bInZ:=IsInCenterOfG(g,i)
if(bInZ){
ret=append(ret,i)
}
}
return ret
}
var gS3 [][]int=[][]int{
{1,2,3},
{2,3,1},
{3,1,2},
{3,2,1},
{1,3,2},
{2,1,3},
}
type S3 struct {
}
func (G S3) inv(a int)int {
n:=len(gS3)
for i:=0;i<n;i++{
if(G.mul(a,i)==0){
return i
}
}
return -1
}
func (G S3) printTable() {
fmt.Printf("GAP[6,1]=S_3:\n")
printGroup(G)
}
func (G S3) mul(a,b int)int {
var ret []int=[]int{0,0,0}
tArr:=gS3[a]
aArr:=gS3[b]
ret[0]=aArr[tArr[0]-1]
ret[1]=aArr[tArr[1]-1]
ret[2]=aArr[tArr[2]-1]
n:=len(gS3)
for i:=0;i<n;i++{
if(ret[0]==gS3[i][0] && ret[1]==gS3[i][1] && ret[2]==gS3[i][2]){
return i
}
}
return -1
}
func (G S3) size()int {
return 6
}
var gS5 [][]int=[][]int{
{0,1,2,3,4},
{0,1,2,4,3},
{0,1,3,2,4},
{0,1,3,4,2},
{0,1,4,2,3},
{0,1,4,3,2},
{0,2,1,3,4},
{0,2,1,4,3},
{0,2,3,1,4},
{0,2,3,4,1},
{0,2,4,1,3},
{0,2,4,3,1},
{0,3,1,2,4},
{0,3,1,4,2},
{0,3,2,1,4},
{0,3,2,4,1},
{0,3,4,1,2},
{0,3,4,2,1},
{0,4,1,2,3},
{0,4,1,3,2},
{0,4,2,1,3},
{0,4,2,3,1},
{0,4,3,1,2},
{0,4,3,2,1},
{1,0,2,3,4},
{1,0,2,4,3},
{1,0,3,2,4},
{1,0,3,4,2},
{1,0,4,2,3},
{1,0,4,3,2},
{1,2,0,3,4},
{1,2,0,4,3},
{1,2,3,0,4},
{1,2,3,4,0},
{1,2,4,0,3},
{1,2,4,3,0},
{1,3,0,2,4},
{1,3,0,4,2},
{1,3,2,0,4},
{1,3,2,4,0},
{1,3,4,0,2},
{1,3,4,2,0},
{1,4,0,2,3},
{1,4,0,3,2},
{1,4,2,0,3},
{1,4,2,3,0},
{1,4,3,0,2},
{1,4,3,2,0},
{2,0,1,3,4},
{2,0,1,4,3},
{2,0,3,1,4},
{2,0,3,4,1},
{2,0,4,1,3},
{2,0,4,3,1},
{2,1,0,3,4},
{2,1,0,4,3},
{2,1,3,0,4},
{2,1,3,4,0},
{2,1,4,0,3},
{2,1,4,3,0},
{2,3,0,1,4},
{2,3,0,4,1},
{2,3,1,0,4},
{2,3,1,4,0},
{2,3,4,0,1},
{2,3,4,1,0},
{2,4,0,1,3},
{2,4,0,3,1},
{2,4,1,0,3},
{2,4,1,3,0},
{2,4,3,0,1},
{2,4,3,1,0},
{3,0,1,2,4},
{3,0,1,4,2},
{3,0,2,1,4},
{3,0,2,4,1},
{3,0,4,1,2},
{3,0,4,2,1},
{3,1,0,2,4},
{3,1,0,4,2},
{3,1,2,0,4},
{3,1,2,4,0},
{3,1,4,0,2},
{3,1,4,2,0},
{3,2,0,1,4},
{3,2,0,4,1},
{3,2,1,0,4},
{3,2,1,4,0},
{3,2,4,0,1},
{3,2,4,1,0},
{3,4,0,1,2},
{3,4,0,2,1},
{3,4,1,0,2},
{3,4,1,2,0},
{3,4,2,0,1},
{3,4,2,1,0},
{4,0,1,2,3},
{4,0,1,3,2},
{4,0,2,1,3},
{4,0,2,3,1},
{4,0,3,1,2},
{4,0,3,2,1},
{4,1,0,2,3},
{4,1,0,3,2},
{4,1,2,0,3},
{4,1,2,3,0},
{4,1,3,0,2},
{4,1,3,2,0},
{4,2,0,1,3},
{4,2,0,3,1},
{4,2,1,0,3},
{4,2,1,3,0},
{4,2,3,0,1},
{4,2,3,1,0},
{4,3,0,1,2},
{4,3,0,2,1},
{4,3,1,0,2},
{4,3,1,2,0},
{4,3,2,0,1},
{4,3,2,1,0},
}
type S5 struct {
}
func (G S5) inv(a int)int {
n:=len(gS5)
for i:=0;i<n;i++{
if(G.mul(a,i)==0){
return i
}
}
return -1
}
func (G S5) printTable() {
fmt.Printf("GAP[120,34]=S_5:\n")
printGroup(G)
}
func (G S5) mul(a,b int)int {
var ret []int=[]int{0,0,0,0,0}
tArr:=gS5[a]
aArr:=gS5[b]
ret[0]=aArr[tArr[0]]
ret[1]=aArr[tArr[1]]
ret[2]=aArr[tArr[2]]
ret[3]=aArr[tArr[3]]
ret[4]=aArr[tArr[4]]
n:=len(gS5)
for i:=0;i<n;i++{
if(ret[0]==gS5[i][0] && ret[1]==gS5[i][1] && ret[2]==gS5[i][2] && ret[3]==gS5[i][3] && ret[4]==gS5[i][4]){
return i
}
}
return -1
}
func (G S5) size()int {
return 120
}
var gC3 [][]int=[][]int{
{1,2,3},
{2,3,1},
{3,1,2},
}
type C3 struct {
}
func (G C3) inv(a int)int {
n:=len(gC3)
for i:=0;i<n;i++{
if(G.mul(a,i)==0){
return i
}
}
return -1
}
func (G C3) printTable() {
fmt.Printf("GAP[3,1]=C_3:\n")
printGroup(G)
}
func (G C3) mul(a,b int)int {
var ret []int=[]int{0,0,0}
tArr:=gC3[a]
aArr:=gC3[b]
ret[0]=aArr[tArr[0]-1]
ret[1]=aArr[tArr[1]-1]
ret[2]=aArr[tArr[2]-1]
n:=len(gC3)
for i:=0;i<n;i++{
if(ret[0]==gC3[i][0] && ret[1]==gC3[i][1] && ret[2]==gC3[i][2]){
return i
}
}
return -1
}
func (G C3) size()int {
return 3
}
func printGroupStruct(g IGroup,s string){
fmt.Printf("羣%s的不變量:",s)
fmt.Println("N0=",calN0(g),",bA=",calbA(g),",bC=",calbC(g),",Z=",calZ(g))
}
func NSGRetInfo(isN int)string{
if(isN==0){
return "是正規子羣"
}else if(isN==1){
return "不是正規子羣"
}else if(isN==2){
return "不是子羣"
}
return ""
}
func main() {
s3 := S3{}
s3.printTable()
printGroupStruct(s3,"GAP[6,1]")
Test1:=[][]int{{0,1,2},{0,3}}
Test2:=[]int{0,0}
for i:=0;i<len(Test1);i++{
isN:=isnormalsubgroup(s3,&Test1[i],Test2[i])
fmt.Println(Test1[i],NSGRetInfo(isN))
}
c3:=C3{}
c3.printTable()
printGroupStruct(c3,"GAP[3,1]")
s5 := S5{}
//s5.printTable()
printGroupStruct(s5,"GAP[120,34]")
}
D:\go20190906\src\SmallRing>go build IRing.go
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
# command-line-arguments
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
D:\go20190906\src\SmallRing>IRing
[0x7FEF9B73C50] ANOMALY: meaningless REX prefix used
R8_52=F_8:
[R8Add]
1 2 3 4 5 6 7 8
2 1 5 8 3 7 6 4
3 5 1 6 2 4 8 7
4 8 6 1 7 3 5 2
5 3 2 7 1 8 4 6
6 7 4 3 8 1 2 5
7 6 8 5 4 2 1 3
8 4 7 2 6 5 3 1
[R8Mul]
1 1 1 1 1 1 1 1
1 2 3 4 5 6 7 8
1 3 4 5 6 7 8 2
1 4 5 6 7 8 2 3
1 5 6 7 8 2 3 4
1 6 7 8 2 3 4 5
1 7 8 2 3 4 5 6
1 8 2 3 4 5 6 7
R4_11=F_4:
[R4Add]
1 2 3 4
2 1 4 3
3 4 1 2
4 3 2 1
[R4Mul]
1 1 1 1
1 2 3 4
1 3 4 2
1 4 2 3
R4_3=Z/4Z:
[R4Add]
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
[R4Mul]
1 1 1 1
1 2 3 4
1 3 1 3
1 4 3 2
R4_2=2Z/8Z:
[R4Add]
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
[R4Mul]
1 1 1 1
1 3 1 3
1 1 1 1
1 3 1 3
N0(r8_52)= [1 2 2 2 2 2 2 2]
N0(r4_11)= [1 2 2 2]
N0(r4_3)= [1 4 2 4]
N0(r4_2)= [1 4 2 4]
package main
import "fmt"
//接口的定義
type IRing interface {
printTable()
add(a,b int)int
mul(a,b int)int
size()int
}
//接口的實現
//Z/4Z
type R4_3 struct {}
func (R R4_3)printTable(){
fmt.Println("R4_3=Z/4Z:")
printRing(R)
}
func (R R4_3)add(a,b int)int{
return (a+b)%4
}
func (R R4_3)mul(a,b int)int{
return (a*b)%4
}
func (R R4_3)size()int{
return 4
}
//接口的實現
//2Z/8Z
type R4_2 struct {}
func (R R4_2)printTable(){
fmt.Println("R4_2=2Z/8Z:")
printRing(R)
}
func (R R4_2)add(a,b int)int{
return ((2*a+2*b)%8)/2
}
func (R R4_2)mul(a,b int)int{
return ((2*a*2*b)%8)/2
}
func (R R4_2)size()int{
return 4
}
//接口的實現
//F_4
/*
+ O=(0,0),I=(1,1),A=(0,1),B=(1,0)
O O I A B
I I O B A
A A B O I
B B A I O
*/
/*
* O=(0,0),I=(1,1),A=(0,1),B=(1,0)
O O O O O
I O I A B
A O A B I
B O B I A
I,A,B構成一個C_3羣=>A*A=B,B*B=A,A*B=B*A=I,I是乘法單位元
*/
var gF4 []string=[]string{"O","I","A","B"}
var gF4Add [][]string=[][]string{
{"O","I","A","B"},
{"I","O","B","A"},
{"A","B","O","I"},
{"B","A","I","O"},
}
var gF4Mul [][]string=[][]string{
{"O","O","O","O"},
{"O","I","A","B"},
{"O","A","B","I"},
{"O","B","I","A"},
}
type R4_11 struct {}
func (R R4_11)getIdx(s string)int{
for i:=0;i<len(gF4);i++{
if(gF4[i]==s){
return i
}
}
return -1
}
func (R R4_11)printTable(){
fmt.Println("R4_11=F_4:")
printRing(R)
}
func (R R4_11)add(a,b int)int{
ret:=R.getIdx(gF4Add[a][b])
return ret
}
func (R R4_11)mul(a,b int)int{
ret:=R.getIdx(gF4Mul[a][b])
return ret
}
func (R R4_11)size()int{
return 4
}
var gF8Add [][]int=[][]int{
{0, 1, 2, 3, 4, 5, 6, 7},
{1, 0, 4, 7, 2, 6, 5, 3},
{2, 4, 0, 5, 1, 3, 7, 6},
{3, 7, 5, 0, 6, 2, 4, 1},
{4, 2, 1, 6, 0, 7, 3, 5},
{5, 6, 3, 2, 7, 0, 1, 4},
{6, 5, 7, 4, 3, 1, 0, 2},
{7, 3, 6, 1, 5, 4, 2, 0},
}
var gF8Mul [][]int=[][]int{
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 1, 2, 3, 4, 5, 6, 7},
{0, 2, 3, 4, 5, 6, 7, 1},
{0, 3, 4, 5, 6, 7, 1, 2},
{0, 4, 5, 6, 7, 1, 2, 3},
{0, 5, 6, 7, 1, 2, 3, 4},
{0, 6, 7, 1, 2, 3, 4, 5},
{0, 7, 1, 2, 3, 4, 5, 6},
}
type R8_52 struct {}
func (R R8_52)printTable(){
fmt.Println("R8_52=F_8:")
printRing(R)
}
func (R R8_52)add(a,b int)int{
ret:=gF8Add[a][b]
return ret
}
func (R R8_52)mul(a,b int)int{
ret:=gF8Mul[a][b]
return ret
}
func (R R8_52)size()int{
return 8
}
func printRing(r IRing){
n:=r.size()
fmt.Printf("[R%dAdd]\n",n)
for i:=0;i<n;i++{
for j:=0;j<n;j++{
ij:=r.add(i,j)
fmt.Printf("%d ",ij+1)
}
fmt.Printf("\n")
}
fmt.Printf("[R%dMul]\n",n)
for i:=0;i<n;i++{
for j:=0;j<n;j++{
ij:=r.mul(i,j)
fmt.Printf("%d ",ij+1)
}
fmt.Printf("\n")
}
}
// 環的加法羣的羣元的階
func getGOrder(r IRing,a int)int{
n:=r.size()
if(a<0||a>=n){
return -1
}
t:=0
for i:=1;i<=n;i++{
t=r.add(t,a)
if(t==0){
return i
}
}
return -1
}
// 未經排序的羣元階的分佈
func calN0(r IRing)[]int{
ret:=[]int{}
n:=r.size()
for i:=0;i<n;i++{
ord:=getGOrder(r,i)
ret=append(ret,ord)
}
return ret
}
func main() {
r8_52 := R8_52{}
r4_11 := R4_11{}
r4_3 := R4_3{}
r4_2 := R4_2{}
var i IRing
i = r8_52
i.printTable()
i = r4_11
i.printTable()
i = r4_3
i.printTable()
i = r4_2
i.printTable()
fmt.Println("N0(r8_52)=",calN0(r8_52))
fmt.Println("N0(r4_11)=",calN0(r4_11))
fmt.Println("N0(r4_3)=",calN0(r4_3))
fmt.Println("N0(r4_2)=",calN0(r4_2))
}