一、题目要求：

内容：

        求取集合A上的整除关系R对应的盖住关系，并判定偏序集<A，R>是否为格，若是格，判断其是否为有补格。

要求：

        集合A可以是用户任意给定的正整数集合。

二、实验原理以及内容：

实验所使用的数据结构、存储结构：列表及其sort排序，元祖(a,b)表示a|b(a整除b)以及map映射

实验中函数：

def judge_div(a,b)  #判断整除关系 1、0表示是否满足整除关系

def judge_COV(A) #传入集合A，先判断符合整除关系的R集合，再判断出盖住关系，以列表的形式返回盖住关系（其中调用judge_div(a,b)函数来判断R集合）

def union(a,b,A) #A集合中a、b元素的并运算(得两者上确界)

def intersect(a,b,A) #A集合中a，b元素的交运算(得两者的下确界)，其中调用judge_div(a,b)函数向下遍历A中的元素，寻找最小下界（存在,则返回上下确界,不存在返回0）

def judge_lattice(A) #判断是否是格以及是不是补格,根据格的定义，调用union和intersect函数去判断。
def print_tuple(R) #格式化输出集合

实验中数据传递关系：输入集合A,元素必须是正整数的集合,逗号隔开相邻元素，调用一系列函数处理即可

实验思路与原理：

• 判断符合整除关系的R集合和盖住关系：逐一遍历A中每个元素，调用judge_div函数判断是否符合整除关系，是->以元祖的形式放入R中。R计算完后，再对R中的每一个序偶（元祖）进行判断:在R集合中，且无第三者逐一遍历是否符合，一旦出现<x,y><y,z>，flag=0，退出循环，若flag经历遍历后仍然为1，放入COVA的序偶中。
• 判断格：从定义出发(任意两个元素都会有上确界和下确界)，调用union和intersect函数求出上下确界即可（存在，则返回上下确界，不存在返回0）
• 判断有补格：在是格的前提下，对于每一个元素逐一遍历能否找到A中的元素能成为它的补元(并运算后上确界1和交运算后下确界0)即可，（只要找到一个补元即可退出对该元素的讨论，当只有A中每一个元素都有至少一个补元，此时方可判断其为有补格->一旦遍历到一个找不到补元的元素，直接退出循环，flag2=0，不是补元）

时间复杂度：O（n²）

三、源代码：

#盖住关系的求取及格的判定.py
def judge_div(a,b):
    '''a整除b->b除以a为整数'''
    max=(a if a>b else b)
    min=a+b-max
    if max%min==0:#整除
        return 1
    else:
        return 0
 
def judge_COV(A):#传入集合A，判断符合整除关系的R集合，再判断出盖住关系
    R=[]#存储R集合
    for i in A:
        for j in A[A.index(i):]:
            if judge_div(i,j):
                R.append(tuple([i,j]))
    #得出R关系的集合，下求COV A
    COVA=[]
    for x in R:
        if x[1]-x[0]==1:
            COVA.append(x)
        elif (x[1]-x[0])>1: #注意排除自反的<1,1>等元素
            flag=1 #假设符合
            template=A[A.index(x[0])+1:A.index(x[1])]
            for y in template:
                if R.count(tuple([x[0],y]))==1 and R.count(tuple([y,x[1]]))==1:  #中间无其他元素才能满足盖住关系
                    flag=0
                    break
            if flag==1:
                COVA.append(x)
    return COVA
 
'''格式化输出偏序集'''
def print_tuple(R):
    print("{",end="")
    for i in R:
        print("<{0},{1}>".format(i[0],i[1]),end="")
    print("}")
 
'''两个元素的并运算->得到两个元素的上确界'''
def union(a,b,A):
    max=(a if a>b else b)
    for i in A[A.index(max):]:
        if judge_div(i,a) ==1 and judge_div(i,b)==1:
            return i
    return 0#若为0表示A中的a，b元素的上确界不在A中
'''两个元素的交运算->得到两个元素的下确界'''
def intersect(a,b,A):
    min=(a if a<b else b)
    for i in A[A.index(min)::-1]:
        if judge_div(b,i)==1 and judge_div(a,i)==1:
            return i
    return 0
 
'''判断是否是格以及是不是补格'''
def judge_lattice(A):
    #下面进行格相关的判断(任意两个元素均有其上确界和下确界)
    flag1=1#格
    flag2=1
    f=1
    for x in A:
        if flag1==0:
            break
        else:
            for y in A[A.index(x)+1:]:
                flag1=bool(union(x,y,A) and intersect(x,y,A))#注意and的返回值！！！！
                if flag1==0:
                    break
    for m in A:
        if f==1:
            f=0
            for n in A:
                if intersect(m,n,A)==A[0] and union(m,n,A)==A[-1]:
                    f=1
                    break
        else:
            flag2=0
    if flag1==0:
        print("<A,|>不是一个格")
    elif flag2==0:
        print("<A,|>是一个格,但并非有补格")
    else:
        print("<A,|>是一个格，且为有补格")
 
if __name__=="__main__":
    #输入集合A,集合A可以是用户任意给定的正整数集合。
    tempstr=input("输入集合A,元素必须是正整数的集合,逗号隔开相邻元素")
    Alist=tempstr.split(",")
    A=list(map(int,Alist))
    A.sort(reverse=False)#升序排序 例如：1 2 4 8等
    COVA=judge_COV(A)
    print("A对应的盖住关系为:",end="")
    print_tuple(COVA)
    judge_lattice(A)

2022.6.29写在最后，

有一个样例没有考虑，读者可以自行修改，此样例见下。