代数运算的判定
实验内容：
给定一个集合A和该集合上的一个二元运算*，编写程序（集合和运算具有普遍性），验证该运算是否满足结合律、交换律、幂等律、消去律，并计算幺元、零元、幂等元、可消去元、逆元。
实验原理：
对于任意抽象的二元代数系统<A, *>，可以定义结合律、交换律、消去律、幂等律等运算定律和幺元、零元等特殊元素。
1．结合律
设“*”是集合A上的二元运算，<A, *>是代数系统，如果对任意的a, b, c ∈A，都有
(a * b) * c = a * (b * c)，
则称“*”在A上是可结合的(Associative)，或称“*”满足结合律(Associative Law)。
2．交换律
设“*”是集合A上的二元运算，<A, *>是一个代数系统，如果对任意的a, b∈A，都有
a * b = b * a，
则称“*”在A上是可交换的(Commutative)，或称“*”满足交换律(Commutative Law)。
3．消去律
设“*”是集合A上的二元运算，<A, *>是代数系统，元素a∈A，
（1）对任意x, y∈A，都有
如果a * x = a * y，那么x = y，
则称a在A中关于“*”是左可消去元(Left Cancellative Element)；
（2）对任意x, y∈A，都有
如果x * a = y * a，那么x = y，
则称a在A中关于“*”是右可消去元(Right Cancellative Element)；
（3）如果a既是A左可消去元又是右可消去元，则称a是A的可消去元(Cancellative)；
（4）若A中所有元素都是可消去元，则称“*”在A上是可消去的，或称“*”满足消去律(Cancellative Law)。
4．幂等律
设“*”是集合A上的二元运算，<A, *>是代数系统，若元素a∈A，满足
a*a = a，
则称a是A中关于“*”的一个幂等元(Idempotent Element)，简称a为幂等元。若A中的每一个元素都是幂等元，则称“*”在A中是幂等的(Idempotent)，或称“*”满足幂等律(Idempotent Law)。
5．幺元
设“*”是集合A上的二元运算，<A, *>是代数系统，若存在e∈A，对任意a∈A，都有
a * e = e * a = a，
则称e是A中关于运算“*”的一个幺元(Identity Element)，或称单位元(Unit Element)；
6．零元
设“*”是集合A上的二元运算，<A, *>是一个代数系统，若存在q∈A，使得对任意a∈A，都有
a *q = q* a =q，
则称θ是A中关于运算“*”的一个零元(Zero Element)；
7．逆元
设“*”是集合A上的二元运算，<A, *>是一个代数系统，e是A中关于“*”的幺元，元素a∈A，若存在一个元素b∈A，使得：
a * b = b * a = e，
则称a是可逆的(Invertible)，并称b是a的一个逆元(Inverse Element)，记为a-1；
编程实现：
#include <string.h>
#include <iostream>
using namespace std;
#define MAX 26 //最大允许的元素数量为26个，即26个小写英文字母’a’-‘z’
#define VALUE_UNSET 0xfcfcfcfc
int otable[MAX][MAX]; //运算表
int oresult[MAX]; //判定结果
void Init()
{
int i;
for(i = 0; i < MAX; i++)
{
memset(otable[i], VALUE_UNSET, MAX);
}
}
/*
输入操作表
如果输入成功，返回集合大小，否则返回-1
*/
int Input()
{
int count, i, j;
char a, b, c;
cout << "请输入集合大小：" << endl;
cin >> count;
if(count > 26 || count < 1)
{
cout << "输入大小不合法。" << endl;
return -1;
}
cout << "现在假设各元素是：{";
for(i = 0; i < count; i++)
{
cout << (char)('a' + i) << " ";
}
cout << "}" << endl;
cout << "现在请输入操作表：" << endl;
for(i = 0; i < count; i++)
{
for(j = 0; j < count; j++)
{
cout << (char)('a' + i) << "*" << (char)('a' + j) << "=";
cin >> c;
otable[i][j] = c;
}
}
return count;
}
/*
结合律的判定
(a*b)*c = a*(b*c)
*/
void Associative(int n)
{
int i, j, k;
bool cond = true;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
for (k = 0; k < n; k++)
{
if(otable[otable[i][j] - 'a'][k] != otable[i][otable[j][k] - 'a']) // 存在一个不满足条件，即没有结合律
{
cout << "结合律：NO" << endl;
return;
}
}
}
}
cout << "结合律：YES" << endl;
}
/*
交换律的判定
a*b = b*a
*/
void Commutative(int n)
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if(otable[i][j] != otable[j][i]) // 存在一个不满足，即没有交换律
{
cout << "交换律：NO" << endl;
return;
}
}
}
cout << "交换律：YES" << endl;
}
/*
幂等元和幂等律的判定
如果a*a = a，那么a是幂等元
如果所有元素都是幂等元，则称×满足幂等律
*/
void Idempotent(int n)
{
int i, j, k, count;
for (i = 0; i < n; i++)
{
oresult[i] = 0;
}
count = 0;
for (i = 0; i < n; i++) // 判断i是不是幂等元
{
if(otable[i][i] == 'a' + i)
{
oresult[i] = 1;
count++;
}
}
if(count == n)
{
cout << "幂等律：YES" << endl;
}
else
{
cout << "幂等律：YES" << endl;
if(count == 0)
{
cout << "幂等元：NO" << endl;
}
else
{
cout << "幂等元：";
for(i = 0; i < n; i++)
{
if(oresult[i] == 1)
{
cout << (char)('a' + i) << " ";
}
}
cout << endl;
}
}
}
/*
可消去元和可消去律的判定。
如果a*x = a*y,那么x=y --> 左可消去元
如果x*a = y*a,那么x=y --> 右可消去元
如果a既是左可消去元又是右可消去元，则称a是可消去元
如果所有元素都是可消去元，则称×满足消去律
*/
void Cancellative(int n)
{
int i, j, k, count;
for (i = 0; i < n; i++)
{
oresult[i] = 1;
}
count = n;
for (i = 0; i < n; i++) // 判断i是不是可消去元
{
for (j = 0; j < n; j++)
{
for(k = 0; k < n && k != j; k++) // 这里直接把k != j作为判断条件是可以的，并因此减少了重复运算
{
if(otable[i][j] == otable[i][k])
{
oresult[i] = 0;
count--;
goto next;
}
}
}
next:
continue;
}
if(count == n)
{
cout << "可消去律：YES" << endl;
}
else
{
cout << "可消去律：NO" << endl;
if(count == 0)
{
cout << "可消去元：NO" << endl;
}
else
{
cout << "可消去元：";
for(i = 0; i < n; i++)
{
if(oresult[i] == 1)
{
cout << (char)('a' + i) << " ";
}
}
cout << endl;
}
}
}
/*
幺元的判定。返回幺元下标
a*e = e*a = a
*/
int Identity(int n)
{
int i, j;
for (i = 0; i < n; i++) // 判断i是不是幺元
{
for (j = 0; j < n; j++)
{
if((otable[i][j] != 'a' + j) || (otable[j][i] != 'a' + j)) // e*a != a || a*e != a
{
goto next; // 存在某一个不满足条件，即可判定i不是幺元
}
}
cout << "幺元：" << (char)('a' + i) << endl;
return i;
next:
continue;
}
cout << "幺元：无" << endl;
return -1;
}
/*
逆元的判定。
返回可逆元数量。需要先求出幺元，才可以求逆元。第二个参数unit就是幺元
a*b = b*a = e
*/
int Invertible(int n, int unit)
{
int i, j;
int elems = 0;
int inverses[MAX][MAX];
if(unit == -1)
{
cout << "因为没有幺元，所以没有逆元。" << endl;
return -1;
}
for (i = 0; i < n; i++)
{
oresult[i] = 0;
}
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
inverses[i][j] = 0;
}
}
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if((otable[i][j] == 'a' + unit) && (otable[j][i] == 'a' + unit))
{
oresult[i] = 1;
inverses[i][j] = 1; // 为1时表示元素i的逆元为j
}
}
if(oresult[i] == 1)
{
elems++;
}
}
if(elems == 0)
{
cout << "逆元：NO" << endl;
}
else
{
cout << "逆元：";
for (i = 0; i < n; i++)
{
if(oresult[i] == 1)
{
cout << (char)('a' + i) << ":";
for (j = 0; j < n; j++)
{
if(inverses[i][j] == 1)
{
cout << (char)('a' + j) << " ";
}
}
}
}
cout << endl;
}
return elems;
}
/*
零元的判定
返回零元的下标
a*s = s*a = s
*/
int ZeroElemet(int n)
{
int i, j;
for (i = 0; i < n; i++) // 判断i是不是零元
{
for (j = 0; j < n; j++)
{
if((otable[i][j] != 'a' + i) || (otable[j][i] != 'a' + i)) // s*a != s || a*s != s
{
goto next; // 存在某一个不满足条件，即可判定i不是零元
}
}
cout << "零元：" << (char)('a' + i) << endl;
return i;
next:
continue;
}
cout << "零元：无" << endl;
return -1;
}
int main()
{
Init();
int size = Input();
if(size > 0)
{
Associative(size); // 结合律
Commutative(size); // 交换律
Idempotent(size); // 幂等律和幂等元
Cancellative(size); // 消去律和可消去元
int yaoyuan = Identity(size); // 幺元
Invertible(size, yaoyuan); // 逆元
int lingyuan = ZeroElemet(size); // 零元
}
}