别再死记硬背！用Python代码5分钟搞懂离散数学里的命题逻辑

离散数学中的命题逻辑常常让初学者感到抽象难懂，尤其是那些看似复杂的真值表、逻辑联结词和范式转换。但如果你会一点Python编程，情况就完全不同了。本文将带你用代码的方式直观理解这些概念，让抽象的逻辑变得触手可及。

1. 从理论到代码：命题逻辑基础实现

命题逻辑的核心是处理真假值的组合与变换。在Python中，我们可以用最简单的布尔值True和False来表示命题的真假。

首先，让我们定义几个基本的逻辑运算：

def logical_and(p, q):
    return p and q

def logical_or(p, q):
    return p or q

def logical_not(p):
    return not p

def logical_implies(p, q):
    return logical_or(logical_not(p), q)

def logical_equivalent(p, q):
    return logical_and(logical_implies(p, q), logical_implies(q, p))

这些函数实现了最基本的逻辑运算：

• 与(∧) ：两个命题都为真时结果为真
• 或(∨) ：至少一个命题为真时结果为真
• 非(¬) ：命题真值的否定
• 蕴含(→) ：如果p则q
• 等价(↔) ：p和q同真同假

真值表示例 ： 让我们用代码生成一个简单的真值表：

def print_truth_table(operator, name):
    print(f"\n{name} 真值表:")
    print("p\tq\t结果")
    for p in [True, False]:
        for q in [True, False]:
            print(f"{p}\t{q}\t{operator(p, q)}")

# 打印与运算的真值表
print_truth_table(logical_and, "与(AND)")

执行这段代码，你会立即看到逻辑与运算的所有可能组合及其结果。这种可视化方式比死记硬背要直观得多。

2. 命题公式与自动化验证

理解了基本运算后，我们可以处理更复杂的命题公式。比如，验证德摩根律：

# 验证德摩根律：¬(p ∧ q) ⇔ ¬p ∨ ¬q
def test_de_morgan():
    for p in [True, False]:
        for q in [True, False]:
            left = logical_not(logical_and(p, q))
            right = logical_or(logical_not(p), logical_not(q))
            if left != right:
                return False
    return True

print("德摩根律验证结果:", test_de_morgan())

这种自动化验证方法可以轻松扩展到其他逻辑等价式，如分配律、结合律等。通过编写这样的测试函数，你不仅能验证理论，还能深入理解这些定律的实际含义。

常见命题公式类型 ： 我们可以用代码判断一个命题公式的类型：

def formula_type(proposition, variables):
    """
    判断命题公式类型
    返回: "永真式", "永假式" 或 "可满足式"
    """
    from itertools import product
    
    truth_values = list(product([True, False], repeat=len(variables)))
    
    results = []
    for values in truth_values:
        env = dict(zip(variables, values))
        results.append(eval(proposition, {}, env))
    
    if all(results):
        return "永真式"
    elif not any(results):
        return "永假式"
    else:
        return "可满足式"

# 示例：判断 p ∨ ¬p 是永真式
print(formula_type("p or not p", ["p"]))  # 输出: 永真式

3. 范式转换的算法实现

范式（正常形式）是命题逻辑中的重要概念，包括析取范式和合取范式。我们可以用Python实现自动转换：

def to_cnf(expression):
    """
    将命题表达式转换为合取范式(CNF)
    """
    # 实现步骤：
    # 1. 消除蕴含和等价
    # 2. 应用德摩根律
    # 3. 应用分配律
    # 这里简化实现，实际需要更完整的逻辑
    expr = expression.replace("→", "").replace("↔", "")
    return expr

def to_dnf(expression):
    """
    将命题表达式转换为析取范式(DNF)
    """
    # 类似CNF转换，但应用不同的分配律
    expr = expression.replace("→", "").replace("↔", "")
    return expr

# 示例：转换表达式
expr = "(p → q) ∧ (q → r)"
print("合取范式:", to_cnf(expr))
print("析取范式:", to_dnf(expr))

虽然这是一个简化版的实现，但它展示了范式转换的基本思路。完整的实现需要处理更多细节，如正确处理括号、变量名等。

4. 实用案例：逻辑推理系统

最后，让我们构建一个简单的逻辑推理系统，可以验证一些基本的逻辑论证：

def logical_entailment(premises, conclusion):
    """
    验证前提是否逻辑蕴含结论
    """
    variables = set()
    for expr in premises + [conclusion]:
        variables.update(set(c for c in expr if c.isalpha()))
    variables = list(variables)
    
    from itertools import product
    
    for values in product([True, False], repeat=len(variables)):
        env = dict(zip(variables, values))
        premises_true = all(eval(p, {}, env) for p in premises)
        conclusion_false = not eval(conclusion, {}, env)
        
        if premises_true and conclusion_false:
            return False  # 存在反例
    return True  # 无反例，逻辑蕴含成立

# 示例验证
premises = ["p → q", "q → r"]
conclusion = "p → r"
print(f"论证是否有效: {logical_entailment(premises, conclusion)}")

这个简单的推理系统可以验证许多基本的逻辑论证。通过这样的实践，你会对命题逻辑有更深入的理解。

5. 可视化工具增强理解

为了更直观地理解这些概念，我们可以使用Python的可视化库来创建交互式学习工具：

import matplotlib.pyplot as plt
import numpy as np

def plot_truth_table(operator, title):
    fig, ax = plt.subplots()
    data = [[operator(p, q) for q in [True, False]] for p in [True, False]]
    ax.imshow(data, cmap='binary')
    
    ax.set_xticks(np.arange(2))
    ax.set_yticks(np.arange(2))
    ax.set_xticklabels(['T', 'F'])
    ax.set_yticklabels(['T', 'F'])
    ax.set_xlabel('q')
    ax.set_ylabel('p')
    ax.set_title(title)
    
    for i in range(2):
        for j in range(2):
            ax.text(j, i, str(data[i][j]), ha='center', va='center', color='w')
    
    plt.show()

# 绘制与运算的真值表热图
plot_truth_table(logical_and, "AND 运算真值表")

这种可视化方法特别适合视觉学习者，能够快速把握逻辑运算的规律。

6. 实际应用：解决逻辑谜题

让我们用Python解决一个经典逻辑谜题：

题目 ：有三个朋友A、B、C，已知：

1. 如果A说的是真话，那么B说的也是真话
2. 如果B说的是真话，那么C在说谎
3. 如果C在说谎，那么A也在说谎

问：谁在说真话，谁在说谎？

from itertools import product

# 定义变量：a,b,c分别表示A,B,C是否说真话
for a, b, c in product([True, False], repeat=3):
    condition1 = logical_implies(a, b)
    condition2 = logical_implies(b, not c)
    condition3 = logical_implies(not c, not a)
    
    if condition1 and condition2 and condition3:
        print(f"解决方案: A={a}, B={b}, C={c}")
        break

这个例子展示了如何将现实中的逻辑问题转化为可计算的命题逻辑问题，并用穷举法找到解决方案。