使用 Python 进行 AI – 逻辑编程

AI with Python – 逻辑编程基础

本章深入探讨了逻辑编程（Logic Programming），这是一种将程序编写为一组逻辑语句的范式，并探索了其在人工智能（Artificial Intelligence, AI）中使用 Python 的应用。

逻辑本质上是对推理和推断的研究。它允许我们从现有为真的陈述中推导出新的信息。例如，如果我们知道“所有人都会死”和“苏格拉底是人”，我们可以推断出“苏格拉底会死”。

逻辑编程概念

逻辑编程结合了“逻辑”和“编程”。它是一种编程范式，其中问题通过形式逻辑系统内的事实（facts）和规则（rules）来描述。您无需指定如何实现目标（命令式编程），而是指定目标是什么以及涉及的逻辑关系（声明式编程）。系统随后使用推理引擎（inference engine）来寻找满足这些逻辑条件的解决方案。Prolog 是这种范式中一种知名的语言；Python 提供了 kanren 等库来实现类似的功能。

使用逻辑编程解决问题

逻辑编程依赖于两个基本构建块：事实（Facts）和规则（Rules）。为了解决问题，您需要为您的领域定义这些，并指定一个目标（查询，query）。

事实（Facts）

事实是关于问题领域的无条件为真的陈述。它们断言已知信息。例如：capital('India', 'New Delhi'). 或 father('John', 'Peter'). 这些是您的逻辑程序处理的基本数据片段。

规则（Rules）

规则定义关系，并允许系统从现有事实推断出新的事实。它们是条件语句，通常写成逻辑子句。例如，定义祖先的规则可以是：ancestor(X, Y) :- parent(X, Y). （如果 X 是 Y 的父辈，则 X 是 Y 的祖先）。

规则对于解决复杂问题至关重要。一般语法通常是 Head :- Body.，可以理解为“如果 Body 为真，则 Head 为真。”Body 可以包含一个或多个由逻辑 AND（通常是逗号）或 OR（通常是针对相同 Head 的独立规则）连接的子目标（条件）。

更复杂规则的示例：

ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).

这可以理解为：“X 是 Z 的祖先，如果 X 是 Y 的父辈，并且 Y 是 Z 的祖先。”这是一个递归定义。推理引擎使用这些规则来搜索查询的解决方案。

用于逻辑编程的重要 Python 包

为了在 Python 中实现逻辑编程概念，我们将主要使用 kanren 库。SymPy 对于符号数学（有时与逻辑编程任务交叉）也很有用。

Kanren

kanren 是一个支持关系型编程和逻辑编程的 Python 库。它允许您使用事实和规则来表达逻辑，并查询解决方案。通过 pip 安装：

pip install kanren

SymPy

SymPy 是一个用于符号数学的 Python 库。虽然它并非严格意义上的逻辑编程工具，但对于涉及代数操作的问题很有用，这些问题可以用声明式方式表达。通过 pip 安装：

pip install sympy

使用 Kanren 在 Python 中进行逻辑编程的示例

让我们使用 kanren 探索一些实际示例。

1. 匹配数学表达式

逻辑编程可用于通过匹配模式来查找表达式中的未知值。此示例演示了 kanren 如何在代数表达式中匹配和求解变量。

首先，从 kanren 导入必要的组件：

from kanren import run, var, fact, conde,Relation, facts
from kanren.assoccomm import eq_assoccomm as eq_ac # For associative-commutative equality
from kanren.assoccomm import commutative, associative

将数学运算定义为常量：

add = 'add'
mul = 'mul'

指定加法和乘法是满足交换律（commutative）和结合律（associative）的运算。这些是 kanren 的事实：

fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)

使用 var() 声明逻辑变量（logic variables）：

a, b = var('a'), var('b')
x, y, z = var('x'), var('y'), var('z')

定义一个原始模式，例如 (5 + a) * b。在 kanren 中，这表示为嵌套的元组：

original_pattern = (mul, (add, 5, a), b) # Represents (5 + a) * b

定义要与此模式匹配的表达式：

exp1 = (mul, (add, 5, 3), 2)  # (5 + 3) * 2
exp2 = (mul, 2, (add, 5, 3))  # 2 * (5 + 3) (commutative)
exp3 = (add, 5, (mul, 8, 1))  # 5 + (8 * 1) (different structure)

使用 run 来查找解决方案。run(0, (a,b), goal) 表示找到满足目标的 a 和 b 的所有解决方案。eq_ac 检查相等性时会考虑结合律和交换律。

print(f"模式: {original_pattern}")
print(f"表达式 1: {exp1} -> (a,b) 的解: {run(0, (a,b), eq_ac(original_pattern, exp1))}")
print(f"表达式 2: {exp2} -> (a,b) 的解: {run(0, (a,b), eq_ac(original_pattern, exp2))}")
print(f"表达式 3: {exp3} -> (a,b) 的解: {run(0, (a,b), eq_ac(original_pattern, exp3))}")

预期输出：

Pattern: ('mul', ('add', 5, _a), _b)
Expression 1: ('mul', ('add', 5, 3), 2) -> Solutions for (a,b): ((3, 2),)
Expression 2: ('mul', 2, ('add', 5, 3)) -> Solutions for (a,b): ((3, 2),)
Expression 3: ('add', 5, ('mul', 8, 1)) -> Solutions for (a,b): ()

输出显示 exp1 和 exp2 与模式匹配，得到 a=3, b=2。exp3 不匹配，因此返回空元组 ()，表示没有找到解决方案。

2. 检查质数

逻辑编程可以定义像素数性这样的属性，然后查询满足此属性的数字。此示例使用 kanren 以及 sympy 的 isprime 函数。

导入必要的模块：

from kanren import isvar, run, membero, conde, eq, var, Relation, facts
from sympy.ntheory.generate import prime, isprime
import itertools as it

定义一个目标 prime_check(x)，如果 x 是质数则成功。如果 x 是一个变量，它会生成质数。如果 x 是一个绑定值（ground value），它会检查该值是否为质数。

def prime_check(x_var):
    if isvar(x_var):
        # 如果 x_var 是一个变量，则生成质数
        # conde 接受 (目标列表) 对的列表
        return conde([(eq, x_var, p)] for p in map(prime, it.count(1)))
    else:
        # 如果 x_var 是一个绑定值，则检查它是否为质数
        return conde([(eq, True, isprime(x_var))]) # 如果 isprime(x_var) 为 True 则成功

声明一个逻辑变量：

x = var()

示例 1：在给定列表中查找质数。

number_list = (12, 14, 15, 19, 20, 21, 22, 23, 29, 30, 41, 44, 52, 62, 65, 85)
# 目标：x 是 number_list 的成员 AND x 是质数
result_primes_in_list = run(0, x, membero(x, number_list), prime_check(x))
print(f"列表 {number_list} 中的质数: {set(result_primes_in_list)}")

示例 2：生成前 10 个质数。

# 目标：x 是质数（生成）
result_first_10_primes = run(10, x, prime_check(x)) # 获取 10 个解
print(f"前 10 个质数: {result_first_10_primes}")

预期输出：

Prime numbers in (12, 14, 15, 19, 20, 21, 22, 23, 29, 30, 41, 44, 52, 62, 65, 85): {19, 23, 29, 41}
First 10 prime numbers: (2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

3. 解决逻辑谜题（例如，斑马谜题变体）

逻辑编程擅长解决约束满足问题（constraint satisfaction problems），例如数独或著名的斑马谜题。这里是一个简化版的类似斑马谜题的设置。

谜题陈述（经典版本，略作改编以便简洁）：

1. 有五栋房子，每栋颜色不同，住着不同国籍的人，养着不同的宠物，喝着不同的饮料，抽着不同的香烟。
2. 英国人住在红房子里。
3. 西班牙人养狗。
4. 绿房子里喝咖啡。
5. 乌克兰人喝茶。
6. 绿房子紧挨着象牙白房子的右边。
7. 抽 Old Gold 香烟的人养蜗牛。
8. 黄房子里抽 Kools 香烟。
9. 中间的房子里喝牛奶。
10. 挪威人住在第一栋房子。
11. 抽 Chesterfields 香烟的人住在养狐狸的人隔壁。
12. 抽 Kools 香烟的房子紧挨着养马的房子。
13. 抽 Lucky Strike 香烟的人喝橙汁。
14. 日本人抽 Parliaments 香烟。
15. 挪威人住在蓝房子隔壁。
问题：谁喝水？谁养斑马？

导入 kanren 组件：

from kanren import var, run, conde, membero, eq, lall # lall for ANDing multiple goals
import time

定义空间关系（如“隔壁”或“右边”）的辅助函数：

def right_of(item1, item2, items_list):
    # item1 紧挨着 item2 的右边
    # 这意味着 (item2, item1) 必须是拉链列表中一对
    return membero((item2, item1), zip(items_list, items_list[1:]))

def next_to(item1, item2, items_list):
    # item1 在 item2 旁边（左边或右边）
    return conde([right_of(item1, item2, items_list)], [right_of(item2, item1, items_list)])

声明一个逻辑变量 houses 来表示 5 个房屋配置的列表。每个房子是一个元组：(国籍, 宠物, 香烟, 饮料, 颜色)。

houses = var() # 这将是一个包含 5 个房屋元组的列表

使用 lall（逻辑与）定义谜题的规则（约束）。这是一组简化的规则，仅供演示。完整的解决方案会更详细。

rules_zebra_puzzle = lall(
    # 规则 1：有 5 栋房子。每栋房子是一个包含 5 个属性的元组。
    (eq, (var(), var(), var(), var(), var()), houses), # 确保 'houses' 是一个包含 5 个元素的列表
    # 'houses' 中的每个元素都是一个 (国籍, 宠物, 香烟, 饮料, 颜色) 元组。
    # 我们最初将每栋房子表示为变量的元组。
    (membero, ('Englishman', var(), var(), var(), 'red'), houses),            # 规则 2
    (membero, ('Spaniard', 'dog', var(), var(), var()), houses),              # 规则 3
    (membero, (var(), var(), var(), 'coffee', 'green'), houses),             # 规则 4
    (membero, ('Ukrainian', var(), var(), 'tea', var()), houses),            # 规则 5

    # 规则 6：绿房子在象牙白房子的右边。
    # 设 house_g = (..., 'green') 且 house_i = (..., 'ivory')
    (right_of, (var(),var(),var(),var(),'green'),
                 (var(),var(),var(),var(),'ivory'), houses),

    (membero, (var(), 'snails', 'Old Gold', var(), var()), houses),         # 规则 7
    (membero, (var(), var(), 'Kools', var(), 'yellow'), houses),             # 规则 8

    # 规则 9：牛奶在中间房子。houses 是 0 索引列表 [h0, h1, h2, h3, h4]
    # 所以中间房子是 houses[2]
    (eq, (var(), var(), (var(),var(),var(),'milk',var()), var(), var()), houses),

    # 规则 10：挪威人在第一栋房子 (houses[0])
    (eq, (('Norwegian',var(),var(),var(),var()), var(),var(),var(),var()), houses),

    # 规则 11：抽 Chesterfields 的人住在养狐狸的人隔壁
    (next_to, (var(), var(), 'Chesterfields', var(), var()),
                (var(), 'fox', var(), var(), var()), houses),

    # 规则 12：抽 Kools 的房子紧挨着养马的房子
    (next_to, (var(), var(), 'Kools', var(), var()),
                (var(), 'horse', var(), var(), var()), houses),

    (membero, (var(), var(), 'Lucky Strike', 'orange juice', var()), houses),# 规则 13
    (membero, ('Japanese', var(), 'Parliaments', var(), var()), houses),     # 规则 14

    # 规则 15：挪威人住在蓝房子隔壁
    (next_to, ('Norwegian', var(), var(), var(), var()),
                (var(), var(), var(), var(), 'blue'), houses),

    # 查询：谁喝水？谁养斑马？
    (membero, (var('water_drinker_nationality'), var(), var(), 'water', var()), houses),
    (membero, (var('zebra_owner_nationality'), 'zebra', var(), var(), var()), houses)
)

运行求解器。run(1, ...) 要求一个解决方案。变量 water_drinker_nationality 和 zebra_owner_nationality 将在解决方案中绑定。

print("正在求解斑马谜题（这可能需要一些时间）...")
start_time = time.time()
solutions = run(1, houses, rules_zebra_puzzle) # 请求 houses 的 1 个解决方案
end_time = time.time()
print(f"求解耗时 {end_time - start_time:.2f} 秒。")

# 从解决方案中提取并打印答案
if solutions:
    solution_env = solutions[0] # 绑定变量的环境
    # 要获取 'water_drinker_nationality' 和 'zebra_owner_nationality' 的值，
    # 我们需要使用我们想要获取的特定变量重新运行查询。

    # 我们需要找到包含 'water' 和 'zebra' 的房屋元组
    # 并从该元组中提取国籍。

    # 这需要更复杂的提取或使用特定查询变量重新运行。
    # 为了简单起见，如果打印完整的 'houses' 解决方案，我们将手动检查，
    # 或者使用针对特定变量的精炼查询。

    # 使用已解决的 'houses' 专门查询国籍
    water_drinker_query = run(0, var('nationality'), membero((var('nationality'),var(),var(),'water',var()), solution_env))
    zebra_owner_query = run(0, var('nationality'), membero((var('nationality'),'zebra',var(),var(),var()), solution_env))

    if water_drinker_query:
        print(f"那个{water_drinker_query[0]}人喝水。")
    else:
        print("无法从解决方案中确定谁喝水。")

    if zebra_owner_query:
        print(f"那个{zebra_owner_query[0]}人养斑马。")
    else:
        print("无法从解决方案中确定谁养斑马。\n可能是提供的规则不足或规则定义有问题导致无法找到完整解决方案。")

    # print("房屋的完整解决方案:")
    # for house_detail in solution_env:
    #    print(house_detail)
else:
    print("使用给定规则未找到斑马谜题的解决方案。")

实际的斑马谜题非常复杂，需要正确编码所有 15 条规则。经典谜题的输出通常是挪威人喝水，日本人养斑马。如果所有规则都正确指定，kanren 求解器可以找到这个结果。

逻辑编程是解决可以用对象及其关系表达的问题的强大工具，特别是在专家系统、数据库查询和自动化推理等领域。