判断半群、独异点、群

概念：

半群：

在数学中，半群是闭合于结合性二元运算之下的集合 $S$构成的代数结构。集合 $S$ 和其上的二元运算 $·$ : $S×S→S$ 。若 $·$ 满足结合律，即： $∀x,y,z∈S$，有$(x·y)·z=x·(y·z)$，则称有序对$(S,·)$为半群，运算 $·$ 称为该半群的乘法。实际使用中，在上下文明确的情况下，可以简略叙述为“半群S”。

独异点(幺半群)：

若S上的乘法有幺元(单位元)，即：$∃1∈S$，使得 $∀s∈S$ ，$1·s=s·1$。则S称为幺半群(独异点)。

群：

若独异点中每一个元素都有对应的逆元，则S称为群。

判定条件：

按照定义判断即可

算法实现

简单算法实现(C语言为例)：

//判断系统为半群
int  banqun(int  n)
{
    int flag=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            for(int k=1;k<=n;k++)
            {
                int x=S[i][j];
                int y=S[j][k];
                if(S[x][k]!=S[i][y])
                    flag=0;
            }
    return flag;
}

//判断系统为含幺半群
int yaoqun(int n)
{

    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(S[i][j]==j && S[j][i]==j)
            {
                Y=i;
                return 1;
            }
    return 0;
}
//判断为群
int qun(int n)
{
    int flag1=banqun(n);
    int flag2=yaoqun(n);
    if(flag1&&flag2)
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(S[i][j]!=Y || S[j][i]!=Y)
                    return 0;
    }
    else return 1;
}

简单算法实现(Python为例)：

#判断是否为群
def banqun(n):
    flag=1
    for i in range(1,n):
        for j in range(1,n):
            for k in range(1,n):
                x=S[i][j];
                y=S[j][k];
                if(S[x][k]!=S[i][y]):
                    flag=0;
    return flag;
#判断系统为含幺半群(独异点)
def yaoqun(n):
    for i in range(1, n):
        for j in range(1, n):
            if(S[i][j]==j and S[j][i]==j):
                Y=i
                return 1
    return 0
#判断为群
def qun(n):
    flag1=banqun(n)
    flag2=yaoqun(n)
    if(flag1 and flag2):
        for i in range(1,n):
            for j in range(1,n):
                if(S[i][j]!=Y or S[j][i]!=Y):
                    return 0;
    else:
        return 1

C语言具体实现(编译运行即可使用)

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0

using namespace std;

typedef char ElemType;
typedef int Status;

typedef struct AlgSysNode{
    ElemType *elem;         //元素数组首地址
    ElemType **table;       //运算表首地址
    int length;             //元素个数
}AlgSysNode,*AlgSystem;

//创建代数系统
void createAlgSystem(AlgSystem &G,int n){
    int i,j;
    G = (AlgSystem)malloc(n*sizeof(AlgSysNode));
    if(!G) return;
    G->elem = (ElemType *)malloc(n*sizeof(ElemType));
    if(!G->elem) return;
    for(i=0;i<n;i++){
        printf("第%d个元素是：",i+1);
        cin>>G->elem[i];
    }
    G->table = (ElemType **)malloc(n*sizeof(ElemType*));
    if(!G->table) return;
    for(i=0;i<n;i++){
        G->table[i] = (ElemType *)malloc(n*sizeof(ElemType));
        for(j=0;j<n;j++){
            printf("运算表中第%d行第%d个是：",i+1,j+1);
            cin>>G->table[i][j];
        }
    }
    G->length = n;
    return;
}

//定位元素
int LocateVex(AlgSystem G,ElemType e){
    int i;
    for(i=0;i<G->length;i++){
        if(G->elem[i] == e) return i;
    }
    return -1;
}

//封闭性
Status IsClosed(AlgSystem G){
    int i,j;
    for(i=0;i<G->length;i++){
        for(j=0;j<G->length;j++){
            if(LocateVex(G,G->table[i][j])==-1) return FALSE;
        }
    }
    return TRUE;
}

//结合性
Status IsCombined(AlgSystem G){
    int i,j,k,m,n;
    for(i=0;i<G->length;i++){
        for(j=0;j<G->length;j++){
            for(k=0;k<G->length;k++){
                m = LocateVex(G,G->table[i][j]);
                n = LocateVex(G,G->table[j][k]);
                if(G->table[m][k] != G->table[i][n]){
                    return FALSE;
                }
            }
        }
    }
    return TRUE;
}

//有幺元
Status IsExist_e(AlgSystem G,ElemType &e){
    int i,j,k;
    for(i=0;i<G->length;i++){
        for(j=0;j<G->length;j++){
            if(G->table[i][j] != G->elem[j]) break;
        }
        if(j == G->length){
            for(k=0;k<G->length;k++){
                if(G->table[k][i] != G->elem[k]) break;
            }
            if(k == G->length){
                e =  G->elem[i];
                return TRUE;
            }
        }
    }
    return FALSE;
}

//逆元
Status IsExistInverse_e(AlgSystem G,ElemType e){
    int i,j;
    for(i=0;i<G->length;i++){
        for(j=0;j<G->length;j++){
            if(G->table[i][j] == e) break;
        }
        if(j == G->length) return FALSE;
    }
    return TRUE;
}

Status IsGroup(AlgSystem G){
    ElemType e;
    return IsClosed(G) && IsCombined(G) && IsExist_e(G,e) && IsExistInverse_e(G,e);
}

int main(){
    int n = 0;
    AlgSystem G;
    printf("代数系统中元素的个数：");
    scanf("%d",&n);
    createAlgSystem(G,n);
    if( IsClosed(G)&&IsCombined(G)){
            printf("该代数系统是半群\n");
            ElemType e;
            if(IsCombined(G)){
                printf("该代数系统是独异点\n");
            }
        }else{
            printf("该代数系统不是半群") ;
        }
    if(IsGroup(G)){
        printf("该代数系统是群");
    }else{
        printf("该代数系统不是群") ;
    }
    return 0;
}

Python具体实现(运行即可使用)

#判断是否为半群
def banqun(n,S):
    flag=1
    for i in range(1,n):
        for j in range(1,n):
            for k in range(1,n):
                x=S[i][j];
                y=S[j][k];
                if(S[x][k]!=S[i][y]):
                    flag=0;
    return flag;
#判断系统为含幺半群(独异点)
def yaoqun(n,S):
    for i in range(1, n):
        for j in range(1, n):
            if(S[i][j]==j and S[j][i]==j):
                Y=i
                return 1,Y
    return 0,0
#判断为群
def qun(n,S):
    flag1=banqun(n,S)
    flag2,Y=yaoqun(n,S)
    if(flag1 and flag2):
        for i in range(1,n):
            for j in range(1,n):
                if(S[i][j]!=Y or S[j][i]!=Y):
                    return 0;
    else:
        return 1

if __name__ == '__main__':
    n = int(input('请输入矩阵的大小'))
    a = [[0 for i in range(n+1)] for j in range(n+1)]
    print('输入整个矩阵(一个一个输入，按照行次序)')
    for i in range(n):
        for j in range(n):
            a[i+1][j+1] = int(input())
    ans1 = banqun(n,a)
    ans2 = yaoqun(n,a)
    ans3 = qun(n,a)
    if ans1 == 1:
        print('是半群')
    if ans2 == 1:
        print('是含幺半群')
    if ans3 == 1:
        print('是群')