离散数学实验（三）：偏序关系中盖住关系的求取以及格代数系统中有补格的判定

离散数学实验（三）

1、介绍

函数功能为偏序关系中盖住关系的求取以及格代数系统中有补格的判定，使用Python实现。本文内容包含了具体代码以及测试。

2、具体代码

import pandas as pd

factor_set = []  # 全局变量集合，记录正整数所有的正因数
partial_order_set = []  # 全局变量记录偏序关系
COV_set = []    # 全局变量，记录盖住关系
relation_table = pd.DataFrame()     # 使用pandas库的dateframe对象保存关系矩阵，用于后面判断格和有补格


# 输入一个正整数，找到他的正因子集合
def get_positive_factors():
    global factor_set  # 声明全局变量因数集合
    n = eval(input("请输入一个正整数: "))
    # 循环遍历从1到n，找出n的所有因子并添加到factor_set列表
    for i in range(1, n + 1):
        if n % i == 0:
            factor_set.append(i)
    # 输出结果
    print("\033[1;32m正整数{}的正因子集合:\033[0m {}".format(n, set(factor_set)))
    print()


# 求出因子集合中整除的偏序关系
def partial_order_relation():
    global partial_order_set, relation_table    # 声明全局变量

    li = factor_set
    length = len(li)
    # 初始化dataframe对象，让其元素为0
    ini_row = []    # 生成一个n行n列的二维列表，让其初始值为0
    for m in range(length):
        element = []
        for n in range(length):
            element.append(0)
        ini_row.append(element)
    # 生成dateframe对象，所有元素值为0，找整除关系时更新该矩阵，让其结果为1表示存在整除关系
    relation_table = pd.DataFrame(ini_row, index=factor_set, columns=factor_set)
    # 遍历任意两个整数，确认是否存在整除关系，同时更新偏序关系列表和关系矩阵
    for i in range(length):
        j = i
        while j < length:
            if li[j] % li[i] == 0:
                relation_table.loc[li[i], li[j]] = 1    # 更新关系矩阵
                partial_order_set.append("<{}, {}>".format(li[i], li[j]))   # 更新关系列表
            j += 1
    # 打印结果
    print("\033[1;32m偏序关系为:\033[0m", set(partial_order_set))
    print()
    print("\033[1;32m偏序关系矩阵为:\033[0m")
    print(relation_table)
    print()


# 求出偏序关系中的盖住关系
def search_cov():
    global partial_order_set, factor_set, relation_table, COV_set   # 声明全局变量
    for item in partial_order_set:
        flag = True     # 标志变量记录当前序偶是不是盖住关系
        pre = eval(item.replace("<", "").replace(">", "").split(",")[0])    # 当前序偶的第一元素
        tail = eval(item.replace("<", "").replace(">", "").split(",")[1])   # 当前序偶的第二元素
        # 条件1：序偶两个元素不能相等，相等则不是盖住关系
        if pre == tail:
            flag = False
        else:
            for ele in factor_set:
                # 条件2：存在不与当前序偶中元素相等的其他任意一个元素使得第一元素能整除该元素，该元素能整除第二元素，则不是盖住关系
                if ele != pre and ele != tail:
                    if relation_table.loc[pre, ele] == 1 and relation_table.loc[ele, tail] == 1:
                        flag = False
        # 两个条件都满足，当前序偶是盖住关系，添加进盖住关系列表
        if flag:
            COV_set.append(item)
    # 打印结果
    print("\033[1;32m盖住关系为:\033[0m ", set(COV_set))
    print()


# 格判断函数
def is_a_lattice():
    print("\033[1;32m格的判断:\033[0m")
    global relation_table, factor_set   # 声明全局变量
    flag = True     # 标志变量，标志当前偏序关系是不是格
    length = len(factor_set)
    for i in range(length):
        flag1 = False   # 标志变量，标志当前两个元素是否存在最小上界
        flag2 = False   # 标志变量，标志当前两个元素是否存在最大下界
        j = i
        while j < length:
            for ele in factor_set:
                # 判断任意两个元素是否存在最小上界
                if relation_table.loc[factor_set[i], ele] == 1 and relation_table.loc[factor_set[j], ele] == 1:
                    flag1 = True
                    # 打印结果
                    print("{}和{}的最小上界是: {}".format(factor_set[i], factor_set[j], ele), end=", ")
                    break

            li = factor_set[::-1]
            for ele2 in li:
                # 判断任意两个元素是否存在最大下界
                if relation_table.loc[ele2, factor_set[i]] == 1 and relation_table.loc[ele2, factor_set[j]] == 1:
                    flag2 = True
                    # 打印结果
                    print("最大下界是: {}".format(ele2))
                    break
            j += 1
            # 当前两个元素没有同时存在最大下界和最小上界
            if flag1 is not True or flag2 is not True:
                flag = False
        # 只要存在某两个元素没有最大下界或者最小下界，就能证明当前偏序不是格
        if not flag:
            break
    # 打印结果
    if flag:
        print("任意两个元素都有最小上界和最大下界，所以该偏序关系构成格\n")
    else:
        print("该偏序关系不能构成格\n")


# 此函数传入两个参数判断当前两个元素是否有上、下确界，如果有继续判断上、下确界是否等于全上界1、全下界0，返回布尔值
def exist_complement_element(e1, e2):
    global relation_table, factor_set  # 声明全局对象
    infimum = factor_set[0]  # 下确界
    supremacy = factor_set[-1]  # 上确界
    flag1, flag2 = False, False     # 记录当前两个元素的最小上界、最大小结是否等于全上界，全下界
    for ele in factor_set:
        # 找到第一个上界，第一个上界即为当前两个元素的最小上界
        if relation_table.loc[e1, ele] == 1 and relation_table.loc[e2, ele] == 1:
            # 判断是不是等于全上界
            if ele == supremacy:
                flag1 = True
            break   # 找到一个就停止循环，因为只想找到最小上界
    li = factor_set[::-1]   # 将元素列表倒序，原来为从小到大
    for ele2 in li:
        # 找到第一个下界，第一个下界即为当前两个元素的最大下界
        if relation_table.loc[ele2, e1] == 1 and relation_table.loc[ele2, e2] == 1:
            if ele2 == infimum:
                flag2 = True
            break   # 找到一个就停止循环，因为只想找到最大下界

    # 标志变量同时为真，表示e2是e1的补元
    if flag1 and flag2:
        return True
    else:
        return False


# 有补格的判断
def is_complementary_lattice():
    print("\033[1;32m有补格的判断:\033[0m")
    # 声明全局变量
    global factor_set
    flag = True     # 记录当前关系是不是有补格
    for e1 in factor_set:
        flag1 = False   # 记录当前元素是否有补元
        complement_ele = []
        for e2 in factor_set:
            # 通过调用函数判断e2是不是e1的补元
            if exist_complement_element(e1, e2):
                complement_ele.append(e2)     # 是则添加进补元列表
                flag1 = True    # 更新标志变量
                break
        # 当前元素没有补元
        if flag1 is not True:
            print("{}没有补元".format(e1))
            flag = False    # 更新标志变量
        # 当前元素有补元
        else:
            print("{}的补元是{}".format(e1, str(complement_ele).replace("[", "").replace("]", "")))
    # 打印最终判断结果
    if flag:
        print("每一个元素至少有一个补元， 所以这个格是有补格")
    else:
        print("不是每一个元素都有补元， 所以这个格不是有补格")


def main():
    get_positive_factors()
    partial_order_relation()
    search_cov()
    is_a_lattice()
    is_complementary_lattice()


if __name__ == '__main__':
    main()

3、测试

（1）测试一

输入数据：

6

测试结果：

（2）测试二

输入数据：

8

测试结果：

（3）测试三

输入数据：

12

测试结果：

（4）测试四

输入数据：

9

测试结果：

（5）测试五

输入数据：

17

测试结果：

（6）测试六

输入数据：

125

测试结果：