南京邮电大学离散数学实验三（传递性，自反性，对称性）

0 介绍

离散数学中，传递性、自反性和对称性是关系理论的基本属性，它们在定义和分析各种数学和逻辑结构时扮演着关键角色。理解这些属性对于掌握集合、关系和图论等离散数学领域至关重要。本文将逐一解析这三个属性，并探讨它们在离散数学中的应用和重要性。

让我们从自反性开始。一个关系R在集合A上是自反的，如果对于A中的每个元素x，都有(x, x)属于R。这意味着，关系中的每一个元素都与自身相关。例如，“等于”关系是自反的，因为每个数都等于其自身。自反性在定义诸如等价关系和偏序关系等数学结构时非常重要，因为这些结构通常要求自反性作为其基本性质之一。

接下来是对称性。一个关系R在集合A上是对称的，如果对于A中的任意两个元素x和y，只要(x, y)属于R，那么(y, x)也属于R。换句话说，如果x与y有关系，那么y与x也有同样的联系。例如，“朋友关系”在社交网络中通常是对称的，如果Alice是Bob的朋友，那么Bob也是Alice的朋友。对称性在图论中尤其重要，因为它决定了图的种类（如无向图）。

传递性可能是这三个概念中最复杂的一个。关系R在集合A上是传递的，如果对于A中的任意三个元素x, y, z，只要(x, y)和(y, z)属于R，那么(x, z)也必须属于R。这意味着关系的“传递”能够跨越中间元素。例如，“家族树中的祖先关系”是传递的，如果Alice是Bob的祖先，Bob是Charlie的祖先，那么Alice也是Charlie的祖先。传递性在确定某些数学结构如拓扑和偏序集的连通性和路径问题时非常关键。

在实际应用中，这些属性帮助我们确定数据之间的关系类型，以及如何利用这些关系来设计算法或证明定理。例如，在计算机科学中，自反性、对称性和传递性是决定数据结构（如树或图）中节点关系的关键因素，这直接影响到算法的设计和效率。

在数学证明和逻辑推理中，这些属性提供了一种验证语句或声明正确性的强有力的工具。通过检查给定的关系是否具有自反性、对称性或传递性，我们可以深入理解问题的结构，并找到解决问题的方法。

总的来说，传递性、自反性和对称性是离散数学中关系理论的核心概念，它们在建立和分析数学模型、设计算法和证明定理中起着基础性作用。对这些属性的深入理解和应用，是任何希望在离散数学及相关领域取得进展的学者和专业人士的重要任务。

1 简介

自反性、对称性和传递性是离散数学中用于描述集合上二元关系的重要概念。在集合论和逻辑学中，这些性质被广泛应用，以表达和研究不同对象间的关系。这些性质帮助人们理解和处理在实际问题中遇到的各种关系。以下是对这些性质的详细介绍及其在数学上的应用：

1. 自反性：若集合A上的每个元素a都满足<a, a>属于关系R，则称该关系具有自反性[¹]。这意味着在关系矩阵中，主对角线上的元素均为1[³]。例如，对于集合{1, 2, 3}，如果关系R包含<1, 1>, <2, 2>, 和<3, 3>，则它是自反的。

2. 对称性：若对于集合A上的任意两个元素a和b，只要<a, b>属于关系R，<b, a>也属于关系R，则称该关系具有对称性[¹][²]。在关系矩阵中，这表现为矩阵是对称的，即矩阵的转置与原矩阵相同[³]。例如，对于集合{1, 2, 3}，如果关系R包含<1, 2>和<2, 1>，则它是对称的。

3. 传递性：若对于集合A上的任意三个元素a、b和c，只要<a, b>和<b, c>属于关系R，<a, c>也属于关系R，则称该关系具有传递性[¹][²]。例如，对于集合{1, 2, 3}，如果关系R包含<1, 2>, <2, 3>和<1, 3>，则它是传递的。

总的来说，自反性、对称性和传递性是分析集合上关系的关键工具。它们不仅在理论研究中占有重要地位，也在实际应用中发挥着重要作用。通过深入理解这些性质，人们可以更好地分析和处理各种关系，从而解决实际问题。

2 代码

public class Math {
    private int[] factor = new int[100];// 存数的所有因子
    private int count = 0;    // 因子计数器
    private boolean[][] coverRelationMatrix = new boolean[100][100];     // 关系矩阵

    // 整除判断
    public boolean exactDivision(int m, int n) {
        return m % n == 0 ? true : false;
    }

    // 计算所有的因子存入数组
    public void getFactor(int n) {
        System.out.print("The factors of " + n + " are: ");
        for (int i = 1; i <= n / 2; ++i) {
            if (n % i == 0) {
                factor[count++] = i;
            }
        }
        factor[count] = n;
    }

    // 递归法计算最大公约数
    public int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    // 求取覆盖关系矩阵
    public void setCoverRelationMatrix() {
        //初始化(先将整除的所有序偶对存入)
        for (int i = 0; i <= count; i++) {
            for (int i1 = i; i1 <= count; i1++) {
                // 将第 i 行，第 i1 列的因子传入判断是否整除的函数 exactDivision(a, b)
                // 如果整除，就存入盖住关系矩阵，使其为 true
                if (exactDivision(factor[i1], factor[i])) {
                    coverRelationMatrix[i][i1] = true;
                }
            }
        }

        // 将传入的序偶对进行严格的定义约束，使其满足偏序关系
        for (int i = 0; i <= count; ++i) {
            for (int i1 = 0; i1 <= count; ++i1) {
                for (int i2 = 0; i2 <= count; ++i2) {
                    // 将满足自反性的去除
                    coverRelationMatrix[i2][i2] = false;
                    // 将满足传递性的去除
                    if (coverRelationMatrix[i][i1] && coverRelationMatrix[i1][i2]) {
                        coverRelationMatrix[i][i2] = false;
                    }
                }
            }
        }
    }

    // 以序偶对的方式输出覆盖关系矩阵
    public void printCoverRelation() {
        System.out.print("Partial order relation set: ");
        for (int i = 0; i <= count; i++) {
            for (int j = 0; j <= count; j++) {
                if (coverRelationMatrix[i][j]) {
                    System.out.print("<" + factor[i] + " " + factor[j] + ">" + " ");
                }
            }
        }
        System.out.println();
    }

    // 打印所有因子
    public void printFactors() {
        for (int i = 0; i <= count; i++) {
            System.out.print(factor[i] + " ");
        }
        System.out.println();
    }

    //判断有补格
    void complemented() {
        System.out.print("Is or Not complemented: ");
        boolean flag;
        int gcd, lmc;
        for (int i = 1; i < count; i++) {
            flag = false;
            for (int j = 1; j < count; j++) {
                if (i == j) {
                    continue;
                }
                // 求得最大公约数，即最大下界
                gcd = gcd(factor[i], factor[j]);
                // 求得最小公倍数，即最小上界
                lmc = factor[i] * factor[j] / gcd;
                if (gcd == factor[0] && lmc == factor[count]) {  //最大下界为 1，最小上界为 n
                    flag = true;
                    break;
                }
                if (flag == false) {
                    System.out.println("Not");
                    return;
                }
            }
        }
        System.out.println("Is");
    }

    public static void main(String[] args) {
        Math math = new Math();
        math.getFactor(57);                     // 传入一个整数计算该数的所有因子作为关系集合
        math.printFactors();                      // 打印所有因子
        math.setCoverRelationMatrix();            // 求取覆盖关系矩阵
        math.printCoverRelation();                // 以序偶对的方式输出覆盖关系矩阵
        math.complemented();                      //判断有补格
    }
}