用Python代码玩转命题逻辑：从德摩根律到真值表实战

数理逻辑是计算机科学的基石，但传统教学中那些抽象的真值表和符号推导常常让人望而生畏。作为开发者，我们完全可以用更直观的方式理解这些概念——通过编写Python代码来自动化验证逻辑定律。本文将带你用不到50行代码构建一个命题逻辑验证工具，不仅能动态生成真值表，还能验证德摩根律等经典定律。

1. 命题逻辑的编程表达基础

在开始编码前，我们需要明确几个核心概念。命题逻辑中的每个命题（如p、q）都可以看作一个布尔变量，而逻辑联结词（与、或、非）则对应Python中的逻辑运算符：

• 非(¬) ： not p
• 与(∧) ： p and q
• 或(∨) ： p or q
• 蕴涵(→) ： (not p) or q
• 等价(↔) ： p == q

# 基础命题运算示例
p = True
q = False

print("¬p:", not p)          # 输出 False
print("p ∧ q:", p and q)     # 输出 False 
print("p ∨ q:", p or q)      # 输出 True
print("p → q:", (not p) or q) # 输出 False
print("p ↔ q:", p == q)      # 输出 False

理解这些对应关系后，我们就可以用代码来表达复杂的逻辑命题。例如德摩根律的第一条： ¬(p ∨ q) ⇔ ¬p ∧ ¬q

2. 构建真值表生成器

真值表是验证逻辑等价性最直接的工具。下面我们实现一个通用真值表生成器：

def generate_truth_table(*propositions):
    """生成包含所有命题组合的真值表"""
    n = len(propositions)
    # 生成所有可能的真值组合
    for bits in range(2**n):
        values = [(bits >> i) & 1 == 1 for i in range(n-1, -1, -1)]
        yield dict(zip(propositions, values))

# 示例：验证p ∨ ¬p (排中律)
print("排中律验证:")
for row in generate_truth_table('p'):
    p = row['p']
    result = p or not p  # p ∨ ¬p
    print(f"p={p}: {result}")  # 永远输出True

这个生成器利用二进制数的位模式来枚举所有可能的真值组合。对于n个命题变量，会产生2^n行结果，覆盖所有情况。

3. 验证经典逻辑定律

现在我们可以用代码验证那些教科书上的重要定律了。让我们从德摩根律开始：

3.1 德摩根律验证

德摩根律有两个关键形式：

1. ¬(p ∨ q) ⇔ ¬p ∧ ¬q
2. ¬(p ∧ q) ⇔ ¬p ∨ ¬q

def verify_de_morgan():
    print("验证德摩根律:")
    for row in generate_truth_table('p', 'q'):
        p, q = row['p'], row['q']
        
        left1 = not (p or q)
        right1 = (not p) and (not q)
        
        left2 = not (p and q) 
        right2 = (not p) or (not q)
        
        print(f"p={p}, q={q}: ¬(p∨q)={left1}, ¬p∧¬q={right1} | ¬(p∧q)={left2}, ¬p∨¬q={right2}")
        
        assert left1 == right1  # 第一条验证
        assert left2 == right2  # 第二条验证

verify_de_morgan()

运行这段代码，你会看到在所有可能的p、q组合下，两边的表达式结果完全一致，验证了德摩根律的正确性。

3.2 蕴涵等值式验证

另一个重要规律是蕴涵等值式：p → q ⇔ ¬p ∨ q

def verify_implication():
    print("\n验证蕴涵等值式:")
    for row in generate_truth_table('p', 'q'):
        p, q = row['p'], row['q']
        
        implication = (not p) or q
        classic_imply = True if (not p) else q
        
        print(f"p={p}, q={q}: p→q={implication}, ¬p∨q={classic_imply}")
        assert implication == classic_imply

verify_implication()

这个验证展示了如何用简单的或运算来表达蕴含关系，这是理解条件语句底层逻辑的关键。

4. 构建逻辑表达式求值器

为了更灵活地验证各种逻辑等价式，我们可以实现一个表达式求值器：

def evaluate_expression(expr, context):
    """安全地评估逻辑表达式"""
    allowed_vars = context.keys()
    allowed_ops = {'and', 'or', 'not', '==', '!='}
    
    # 安全检查
    for token in expr.split():
        if token.isalpha() and token not in allowed_vars and token not in allowed_ops:
            raise ValueError(f"非法变量或操作符: {token}")
    
    return eval(expr, {}, context)

def compare_expressions(expr1, expr2, variables):
    """比较两个逻辑表达式在所有情况下的结果"""
    print(f"\n比较: {expr1} 与 {expr2}")
    headers = list(variables) + [expr1, expr2, "结果"]
    print("\t".join(headers))
    
    for row in generate_truth_table(*variables):
        ctx = {k: v for k, v in row.items()}
        try:
            val1 = evaluate_expression(expr1, ctx)
            val2 = evaluate_expression(expr2, ctx)
            row_values = [str(ctx[v]) for v in variables] + [str(val1), str(val2), str(val1 == val2)]
            print("\t".join(row_values))
            assert val1 == val2
        except Exception as e:
            print(f"评估错误: {e}")
            return False
    return True

# 示例：验证分配律 p ∨ (q ∧ r) ⇔ (p ∨ q) ∧ (p ∨ r)
compare_expressions("p or (q and r)", "(p or q) and (p or r)", ['p', 'q', 'r'])

这个求值器可以处理包含任意数量变量的逻辑表达式，并验证它们的等价性。例如，运行上面的分配律验证，你会看到在所有8种可能的真值组合下，两边的结果完全一致。

5. 逻辑定律的编程实践应用

理解这些逻辑定律不仅是为了应付考试，在实际编程中它们大有用武之地：

5.1 条件语句优化

德摩根律可以帮助我们简化复杂的条件判断：

# 原始条件
if not (user.is_authenticated and user.has_permission):
    print("拒绝访问")

# 应用德摩根律后
if not user.is_authenticated or not user.has_permission:
    print("拒绝访问")

虽然逻辑等价，但后者通常更易读，特别是当条件更复杂时。

5.2 布尔表达式简化

吸收律可以帮助我们减少冗余判断：

# 原始表达式
if (x > 0) or (x > 0 and y < 10):
    do_something()

# 应用吸收律 A ∨ (A ∧ B) ⇔ A
if x > 0:
    do_something()

5.3 数据库查询优化

在构建复杂查询时，这些逻辑定律可以帮助我们重写查询条件：

-- 原始查询
SELECT * FROM users 
WHERE NOT (status = 'active' AND last_login > '2023-01-01')

-- 应用德摩根律优化后
SELECT * FROM users
WHERE status != 'active' OR last_login <= '2023-01-01'

在某些数据库引擎中，优化后的版本可能利用索引更高效。

6. 扩展：可视化逻辑关系

为了让逻辑关系更直观，我们可以用Python的matplotlib来可视化：

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Circle, Rectangle

def draw_venn_diagram():
    fig, ax = plt.subplots(figsize=(8, 4))
    
    # 绘制基本集合
    circle1 = Circle((0.3, 0.5), 0.2, color='blue', alpha=0.3)
    circle2 = Circle((0.7, 0.5), 0.2, color='red', alpha=0.3)
    ax.add_patch(circle1)
    ax.add_patch(circle2)
    
    # 标注
    ax.text(0.15, 0.5, 'p', fontsize=12)
    ax.text(0.85, 0.5, 'q', fontsize=12)
    
    # 德摩根律图示
    ax.text(0.5, 0.8, '¬(p ∨ q) = ¬p ∧ ¬q', ha='center', fontsize=10)
    ax.text(0.5, 0.2, '¬(p ∧ q) = ¬p ∨ ¬q', ha='center', fontsize=10)
    
    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)
    ax.axis('off')
    plt.title("德摩根律可视化")
    plt.show()

draw_venn_diagram()

这段代码会生成一个简单的维恩图，直观展示德摩根律如何转换集合运算关系。