用python实现离散数学关系的一些功能

用python实现离散数学关系的一些功能

n元集合A上的二元关系R和S，使用Python函数实现以下功能：

• R和S的复合运算的矩阵实现
• 判断一个关系是否满足自反性
• 判断一个关系是否满足反自反性
• 判断一个关系是否满足对称性
• 判断一个关系是否满足反对称性
• 判断一个关系是否满足传递性
• 以及闭包的实现

咱们直接进入正文：

#输入A
def Inter():
	a=input("请输入集合A\n")
	a=set(a.replace('{','').replace('}','').split(","))
	a=list(a)
	a.sort()#输入集合A结束
	for i in ['R','S']:
		print ("请输入关系",i)
		rs=input()
		rs=rs.replace('{','').replace('}','').replace('<','').replace('>','')
		rs=rs.split(",")
		if i=='R':
			r=rs
		elif i=='S':
			s=rs
	return a,r,s

#构建矩阵
def Creat_Matrix(a,rs):
	array= [[0]*len(a) for i in range(len(a))]
	for i in range((int)(len(rs)/2)):
		array[a.index(rs[i*2])][a.index(rs[i*2+1])]=1
	return array

#输出矩阵
def Print_Matrix(array,judge):
	if judge=='r':
		print('-'*10,'关系R矩阵为：','-'*10)
	elif judge=='s':
		print('-'*10,'关系S矩阵为：','-'*10)
	for i in range(len(array)):
		print(array[i])
	return 0

#关系的复合运算及结果输出
def Com_Matrix_relation(a,array_r,array_s,judge):
	res= [[0]*len(a) for i in range(len(a))]
	for i in range(len(a)):
		for j in range(len(a)):
			for k in range(len(a)):
				res[i][j] += array_r[k][j] * array_s[i][k]
			if res[i][j]>1:
				res[i][j]=1
	if judge=='r○s':
		print('-'*10,'R○S关系复合运算结果为：','-'*10)
	elif judge=='s○r':
		print('-'*10,'S○R关系复合运算结果为：','-'*10)
	for i in range(len(res)):
		print(res[i])
	return 0

#对称性判断
def Symmetric_Relation(a,array,str_judge):
	for i in range(len(a)):
		for j in range(len(a)):
			if array[i][j]!=array[j][i]:
				print("关系",str_judge,"不是对称的")
				return 0 
		if i==len(a)-1:
			print("关系",str_judge,"是对称的")
			return 0

#反对称性判断
def Un_symmetric_Relation(a,array,str_judge):
	for i in range(len(a)):
		for j in range(len(a)):
			if array[i][j]==array[j][i]:
				if i!=j:
					print("关系",str_judge,"不是反对称的")
					return 0 
		if i==len(a)-1:
			print("关系",str_judge,"是反对称的")
			return 0

#自反性判断
def Contrary_Relation(a,array,str_judge):
	for i in range(len(a)):
		if array[i][i]==0:
			print("关系",str_judge,"不是自反的")
			return 0
		if i==len(a)-1:
			print("关系",str_judge,"是自反的")
			return 0

#反自反性判断
def Un_contrary_Relation(a,array,str_judge):
	for i in range(len(a)):
		if array[i][i]==1:
			print("关系",str_judge,"不是反自反的")
			return 0
		if i==len(a)-1:
			print("关系",str_judge,"是反自反的")
			return 0

#传递性判断
def Transmit_Relation(a,array,str_judge):
	for i in range(len(a)):
		for j in range(len(a)):
			for k in range(len(a)):
				if array[i][j]==1 and array[j][k]==1 :
					if array[i][k]!=1:
						print("关系",str_judge,"不是传递的")
						return 0
		if i==len(a)-1 :
			print ("关系",str_judge,"是传递的")
			return 0

#对称闭包
def Symmetric_Closure(a,array,str_judge):
	judge=0
	print("关系",str_judge,"对称闭包需要添加的关系有")
	for i in range(len(a)):
		for j in range(len(a)):
			if array[i][j]==0 and array[j][i]==1:
				print("<",a[i],",",a[j],">")
				judge=1
	if judge==0:
		print("\t无\n关系",str_judge,"本身就是对称的，s(",str_judge,")=",str_judge)
	return 0

#自反闭包
def Reflexive_Closure(a,array,str_judge):
	judge=0
	print("关系",str_judge,"自反闭包需要添加的关系有")
	for i in range(len(a)):
		if array[i][i]!=0:
			print("<",a[i],",",a[i],">")
			judge=1
	if judge==0:
		print("\t无\n关系",str_judge,"本身就是自反的，s(",str_judge,")=",str_judge)
	return 0

#传递闭包
def Transitive_Closure(a,array,str_judge):
	judge=0
	print("关系",str_judge,"传递闭包需要添加的关系有")
	for i in range(len(a)):
		for j in range(len(a)):
			for k in range(len(a)):
				if array[i][j]==1 and array[j][k]==1 :
					if array[i][k]!=1:
						print("<",a[i],",",a[k],">")
						judge=1
	if judge==0:
		print("\t无\n关系",str_judge,"本身就有传递性，t(",str_judge,")=",str_judge)
	return 0

#正文
a,r,s=Inter()#输入
array_r=Creat_Matrix(a,r)#构造矩阵
array_s=Creat_Matrix(a,s)#构造矩阵
print("菜单\n\
	(1)输出关系矩阵表现\n\
	(2)输出复合运算结果\n\
	(3)关系的对称性判断\n\
	(4)关系的反对称性判断\n\
	(5)关系的自反性判断\n\
	(6)关系的反自反性判断\n\
	(7)关系的传递性判断\n\
	(8)关系的对称闭包s(R)\n\
	(9)关系的自反闭包r(R)\n\
	(10)关系的传递闭包t(R)\n\
	(11)输入新的集合与关系\n\
	(12)退出程序\n\
	")
while True:
	choice=input("请输入你的选择：")
	if choice=='1':
		Print_Matrix(array_r,'r')#输出矩阵
		Print_Matrix(array_s,'s')#输出矩阵
	elif choice=='2':
		Com_Matrix_relation(a,array_r,array_s,'r○s')#复合运算
		Com_Matrix_relation(a,array_s,array_r,'s○r')#复合运算
	elif choice=='3':
		Symmetric_Relation(a,array_r,"R")#对称判断
		Symmetric_Relation(a,array_s,"S")#对称判断
	elif choice=='4':
		Un_symmetric_Relation(a,array_r,"R")#反对称判断
		Un_symmetric_Relation(a,array_s,"S")#反对称判断
	elif choice=='5':
		Contrary_Relation(a,array_r,"R")#自反判断
		Contrary_Relation(a,array_s,"S")#自反判断
	elif choice=='6':
		Un_contrary_Relation(a,array_r,"R")#反自反判断
		Un_contrary_Relation(a,array_s,"S")#反自反判断
	elif choice=='7':
		Transmit_Relation(a,array_r,"R")#传递性判断
		Transmit_Relation(a,array_s,"S")#传递性判断
	elif choice=='8':
		Symmetric_Closure(a,array_r,"R")#对称闭包
		Symmetric_Closure(a,array_s,"S")#对称闭包
	elif choice=='9':
		Reflexive_Closure(a,array_r,"R")#自反闭包
		Reflexive_Closure(a,array_s,"S")#自反闭包
	elif choice=='10':
		Transitive_Closure(a,array_r,"R")#传递闭包
		Transitive_Closure(a,array_s,"S")#传递闭包
	elif choice=='11':
		a,r,s=Inter()#输入
		array_r=Creat_Matrix(a,r)#构造矩阵
		array_s=Creat_Matrix(a,s)#构造矩阵
	elif choice=='12':
		end=input("感谢使用，请输入任意键退出。")
		break
	else :print("你输错了！！！请重新输入")

运行结果

有些代码行存在借鉴，如有侵权，请联系我删除，谢谢！