集合论13个恒等式：从离散数学到Python集合运算的代码验证

发布时间：2026/7/6 21:50:26

集合论13个恒等式：从离散数学到Python集合运算的代码验证

在计算机科学和离散数学的学习中，集合论是最基础也是最重要的概念之一。理解集合运算的基本定律不仅有助于我们建立严谨的数学思维，还能在实际编程中写出更高效、更可靠的代码。本文将带你用Python代码验证集合论的13个基本恒等式，让抽象的数学概念变得具体可操作。

1. 准备工作与环境设置

在开始验证之前，我们需要先准备好Python环境并理解一些基本概念。Python内置的set类型完美支持集合的各种运算，是我们实现验证的理想工具。

首先，我们定义几个示例集合用于后续验证：

# 定义全集U和示例集合A、B、C U = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} A = {1, 2, 3, 4} B = {3, 4, 5, 6} C = {4, 5, 6, 7} # 定义空集 empty_set = set()

在集合论中，补集通常相对于某个全集来定义。在Python中，我们可以用差集运算来实现补集：

def complement(x): return U - x

2. 基本运算定律验证

2.1 幂等律

幂等律指出，集合与自身的并集或交集仍然是它自己：

A ∪ A = A
A ∩ A = A

用Python验证：

# 幂等律验证 print("幂等律验证:") print(f"A ∪ A = {A.union(A)}") # 输出: {1, 2, 3, 4} print(f"A ∩ A = {A.intersection(A)}") # 输出: {1, 2, 3, 4} assert A.union(A) == A assert A.intersection(A) == A

2.2 交换律

交换律说明并集和交集运算的顺序不影响结果：

A ∪ B = B ∪ A
A ∩ B = B ∩ A

Python验证：

# 交换律验证 print("\n交换律验证:") print(f"A ∪ B = {A.union(B)}") # 输出: {1, 2, 3, 4, 5, 6} print(f"B ∪ A = {B.union(A)}") # 输出: {1, 2, 3, 4, 5, 6} print(f"A ∩ B = {A.intersection(B)}") # 输出: {3, 4} print(f"B ∩ A = {B.intersection(A)}") # 输出: {3, 4} assert A.union(B) == B.union(A) assert A.intersection(B) == B.intersection(A)

2.3 结合律

结合律说明多个集合的并集或交集运算顺序不影响最终结果：

(A ∪ B) ∪ C = A ∪ (B ∪ C)
(A ∩ B) ∩ C = A ∩ (B ∩ C)

Python代码验证：

# 结合律验证 print("\n结合律验证:") left_union = A.union(B).union(C) right_union = A.union(B.union(C)) print(f"(A ∪ B) ∪ C = {left_union}") # 输出: {1, 2, 3, 4, 5, 6, 7} print(f"A ∪ (B ∪ C) = {right_union}") # 输出: {1, 2, 3, 4, 5, 6, 7} left_intersect = A.intersection(B).intersection(C) right_intersect = A.intersection(B.intersection(C)) print(f"(A ∩ B) ∩ C = {left_intersect}") # 输出: {4} print(f"A ∩ (B ∩ C) = {right_intersect}") # 输出: {4} assert left_union == right_union assert left_intersect == right_intersect

3. 分配律与德摩根律

3.1 分配律

分配律描述了并集和交集运算之间的分配关系：

A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C)
A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C)

Python实现：

# 分配律验证 print("\n分配律验证:") left_dist_union = A.union(B.intersection(C)) right_dist_union = A.union(B).intersection(A.union(C)) print(f"A ∪ (B ∩ C) = {left_dist_union}") # 输出: {1, 2, 3, 4, 5, 6} print(f"(A ∪ B) ∩ (A ∪ C) = {right_dist_union}") # 输出: {1, 2, 3, 4, 5, 6} left_dist_intersect = A.intersection(B.union(C)) right_dist_intersect = A.intersection(B).union(A.intersection(C)) print(f"A ∩ (B ∪ C) = {left_dist_intersect}") # 输出: {3, 4, 5, 6} print(f"(A ∩ B) ∪ (A ∩ C) = {right_dist_intersect}") # 输出: {3, 4, 5, 6} assert left_dist_union == right_dist_union assert left_dist_intersect == right_dist_intersect

3.2 德摩根律

德摩根律是集合论中最重要的定律之一，描述了补集与并集、交集之间的关系：

∼(A ∪ B) = ∼A ∩ ∼B
∼(A ∩ B) = ∼A ∪ ∼B

Python验证：

# 德摩根律验证 print("\n德摩根律验证:") left_deMorgan_union = complement(A.union(B)) right_deMorgan_union = complement(A).intersection(complement(B)) print(f"∼(A ∪ B) = {left_deMorgan_union}") # 输出: {7, 8, 9, 10} print(f"∼A ∩ ∼B = {right_deMorgan_union}") # 输出: {7, 8, 9, 10} left_deMorgan_intersect = complement(A.intersection(B)) right_deMorgan_intersect = complement(A).union(complement(B)) print(f"∼(A ∩ B) = {left_deMorgan_intersect}") # 输出: {1, 2, 5, 6, 7, 8, 9, 10} print(f"∼A ∪ ∼B = {right_deMorgan_intersect}") # 输出: {1, 2, 5, 6, 7, 8, 9, 10} assert left_deMorgan_union == right_deMorgan_union assert left_deMorgan_intersect == right_deMorgan_intersect

4. 其他重要定律验证

4.1 吸收律

吸收律描述了集合与自身子集的并集和交集的关系：

A ∪ (A ∩ B) = A
A ∩ (A ∪ B) = A

Python代码：

# 吸收律验证 print("\n吸收律验证:") left_absorption_union = A.union(A.intersection(B)) print(f"A ∪ (A ∩ B) = {left_absorption_union}") # 输出: {1, 2, 3, 4} assert left_absorption_union == A left_absorption_intersect = A.intersection(A.union(B)) print(f"A ∩ (A ∪ B) = {left_absorption_intersect}") # 输出: {1, 2, 3, 4} assert left_absorption_intersect == A

4.2 零律与同一律

零律和同一律描述了集合与空集、全集的运算特性：

A ∪ ∅ = A
A ∩ U = A
A ∪ U = U
A ∩ ∅ = ∅

Python验证：

# 零律与同一律验证 print("\n零律与同一律验证:") print(f"A ∪ ∅ = {A.union(empty_set)}") # 输出: {1, 2, 3, 4} print(f"A ∩ U = {A.intersection(U)}") # 输出: {1, 2, 3, 4} print(f"A ∪ U = {A.union(U)}") # 输出: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} print(f"A ∩ ∅ = {A.intersection(empty_set)}") # 输出: set() assert A.union(empty_set) == A assert A.intersection(U) == A assert A.union(U) == U assert A.intersection(empty_set) == empty_set

4.3 排中律与矛盾律

排中律和矛盾律描述了集合与其补集的关系：

A ∪ ∼A = U
A ∩ ∼A = ∅

Python实现：

# 排中律与矛盾律验证 print("\n排中律与矛盾律验证:") print(f"A ∪ ∼A = {A.union(complement(A))}") # 输出: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} print(f"A ∩ ∼A = {A.intersection(complement(A))}") # 输出: set() assert A.union(complement(A)) == U assert A.intersection(complement(A)) == empty_set

4.4 余补律

余补律描述了全集和空集的补集关系：

∼∅ = U
∼U = ∅

Python验证：

# 余补律验证 print("\n余补律验证:") print(f"∼∅ = {complement(empty_set)}") # 输出: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} print(f"∼U = {complement(U)}") # 输出: set() assert complement(empty_set) == U assert complement(U) == empty_set

4.5 双重否定定律

双重否定定律说明补集的补集是原集合：

∼(∼A) = A

Python代码：

# 双重否定定律验证 print("\n双重否定定律验证:") print(f"∼(∼A) = {complement(complement(A))}") # 输出: {1, 2, 3, 4} assert complement(complement(A)) == A

4.6 补交转换律

补交转换律描述了差集可以用补集和交集来表示：

A - B = A ∩ ∼B

Python验证：

# 补交转换律验证 print("\n补交转换律验证:") print(f"A - B = {A - B}") # 输出: {1, 2} print(f"A ∩ ∼B = {A.intersection(complement(B))}") # 输出: {1, 2} assert (A - B) == A.intersection(complement(B))

5. 完整验证脚本与实用技巧

为了便于读者使用，我们将所有验证代码整合成一个完整的Python脚本。这个脚本不仅可以验证所有13个集合恒等式，还包含了一些实用技巧和常见问题的解决方案。

def verify_set_laws(): # 定义全集和示例集合 U = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} A = {1, 2, 3, 4} B = {3, 4, 5, 6} C = {4, 5, 6, 7} empty_set = set() def complement(x): return U - x # 1. 幂等律 assert A | A == A assert A & A == A # 2. 交换律 assert A | B == B | A assert A & B == B & A # 3. 结合律 assert (A | B) | C == A | (B | C) assert (A & B) & C == A & (B & C) # 4. 分配律 assert A | (B & C) == (A | B) & (A | C) assert A & (B | C) == (A & B) | (A & C) # 5. 德摩根律 assert complement(A | B) == complement(A) & complement(B) assert complement(A & B) == complement(A) | complement(B) # 6. 吸收律 assert A | (A & B) == A assert A & (A | B) == A # 7. 零律 assert A | U == U assert A & empty_set == empty_set # 8. 同一律 assert A | empty_set == A assert A & U == A # 9. 排中律 assert A | complement(A) == U # 10. 矛盾律 assert A & complement(A) == empty_set # 11. 余补律 assert complement(empty_set) == U assert complement(U) == empty_set # 12. 双重否定定律 assert complement(complement(A)) == A # 13. 补交转换律 assert A - B == A & complement(B) print("所有集合恒等式验证通过！") verify_set_laws()

在实际应用中，理解这些集合恒等式可以帮助我们：