Prolog逻辑编程入门

可视化演示

Prolog是基于一阶逻辑的声明式编程语言，通过事实与规则描述问题。本文详解Prolog的项与谓词、合一与回溯... 切换模式查看不同维度。

声明式范式

想象你刚被任命为城市档案库的馆长。前任留下一句话：“别给员工写步骤，把城市规则写清楚，他们自己会查。”于是档案库里有了“事实卡片”和“规则手册”。当一个市民来问“我能否进入市政厅？”，档案员不是按某个固定流程执行，而是翻找能证明答案的卡片和规则。

Prolog 就是这样一门“档案馆语言”。它不提供 for 循环或赋值语句，而是让你把领域知识写成事实与规则，再通过查询来获得答案。程序员负责描述“世界是什么样”，Prolog 引擎负责“如何推出你要的答案”。这种范式称为声明式逻辑编程。

Prolog 中的每个知识条目都是一个子句（clause）。事实是无条件成立的关系描述；规则是带条件的逻辑蕴含。程序整体可以看成一个一阶逻辑子集的知识库。用一条最简单的祖先规则来说明：

你不必告诉档案员“先查哪个抽屉、再翻哪页”，规则册已经写明方向。同样，Prolog 程序员把精力放在知识结构上，把搜索路径交给引擎。这种“只问是什么、不管怎么做”的观念，是整个逻辑编程的起点。

事实与规则

档案库里最常见的卡片是事实。比如“艾米的父亲是鲍勃”可以写成 parent(amy, bob).。它不需要任何条件，永远成立。另一类是规则，像“如果 X 是 Y 的父母，且 Y 是 Z 的父母，那么 X 是 Z 的祖父母”。规则是档案库的推理能力。

在 Prolog 中，事实就是一个原子语句。常量以小写字母开头，变量以大写字母或下划线开头。规则形如 head :- body.，body 中的逗号表示逻辑与。一个知识库把事实和规则都放在程序文件里，引擎会统一索引，不依赖书写顺序。例如：

事实描述证据，规则描述证据之间的因果。两者都以子句形式存在，引擎在查询时会把它们都看作候选。就像档案馆里事实是卷宗、规则是法条：证据越全、法条越严谨，推理结论越可靠。学习 Prolog，先要学会把领域知识整理成这样的知识库。

parent(amy, bob).grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

查询与谓词

当市民来办事，档案员先看到他写的问题单。问题单以 ?- 开头，比如 ?- parent(amy, X).，意思是：“请告诉我，谁是艾米的孩子？”查询会让引擎在知识库中搜索所有能让 parent(amy,X) 成立的 X。

这里 parent 是一个谓词（predicate），amy 是原子，X 是变量。谓词名加参数个数决定一个子句的身份；同一个名字不同元数会被视为不同谓词。查询的每个目标是需要被证明的子目标。

除了单个子目标，查询还可以用逗号连接多个子目标，比如 ?- parent(amy, X), parent(X, Y).。匿名变量 _ 表示不关心的位置。这是谓词组合成复合查询的方式。问题单上的变量会被答案一一填上；若引擎找不到任何证据，它会回答 false。就像档案员翻遍全库后说：“查无此证。”查询驱动推理，这一动作贯穿了整个 Prolog 程序的生命周期。

合一机制

档案员拿到问题单后，第一件事是把问题单和卷宗里的卡片进行比对。这个比对不是简单的“相等”，而是双向的模式匹配：如果一边是未知数，另一边是具体信息，就把未知数填上；如果两边都缺失，就让它们彼此挂上钩。这套规则叫合一。

合一的目标是让两个项完全相同。匹配过程中产生的变量绑定叫替换（substitution）。例如查询 parent(amy,X) 与事实 parent(amy,bob) 合一，成功并生成绑定 X=bob。

如果两个参数都是变量，比如 X 和 Y，合一会让 X 与 Y 绑定在一起，之后任一绑定都会同步影响另一个。这使它比普通赋值更强大，也更容易出现“双向绑定”的直觉。档案员比对的不是“一份档案是否等于另一份”，而是“两份档案能不能互相补全”。合一让 Prolog 能够在不知道答案时，“猜出”答案。

回溯机制

档案员查案并不总是一击即中。他会先在第一个岔路口选一本手册，走到底；如果后续条件和证据对不上，就回到最近的岔路口，拿起下一本手册继续试。Prolog 正是这样：深度优先搜索 + 回溯。

每成功选择一个匹配子句，引擎就留下一个选择点。当前面的目标失败，就会撤销最近的变量绑定，退回选择点尝试下一条候选子句。这个过程会一直继续，直到求出全部答案或所有路径都失败。

回溯对应搜索树上的分支回退：失败的路径被剪掉，引擎回到最近的岔路口继续下一个分支。子句书写顺序和子目标顺序会影响搜索顺序与性能，但不影响知识库中已存在的逻辑结论。这就像档案员手中的毛线团：进死胡同时顺着线退回岔口，再换一条走廊。你用 ; 可以要求他继续找下一个答案，而回溯正是他不断折返的动力引擎。

递归与列表

档案库中许多关系是层层递进的：要查祖先，先查父母；要查父母的父母，再往上……Prolog 用递归描述这种链条。递归规则必须包含一个最直接的“底”和一条把问题缩小一步的“梯子”。

以家族祖先为例：祖先可以被定义为父母，或父母的祖先。这就是两个子句：一个终止条件（base case）和一个递归条件。列表是 Prolog 最常用的递归结构，用 [H|T] 把头 H 和尾列表 T 分开。计算列表长度可以这样写：

递归时每次都要先写边界条件，否则查询会无限循环。列表处理也常依靠递归：访问每个元素、拼接两个列表、查找元素，本质都是在 [H|T] 上反复拆分。档案员查祖先时，从当前卷宗出发，沿“父母栏”找到下一个卷宗，再次翻看。列表递归就像这条卷宗链：你只需要知道如何处理当前的这一格，然后放心地把剩下的链条交给下一层。Prolog 的递归之美就在于此。

截断与否定

档案库偶尔会遇到“此案不必再审”的情况。比如规则写明：某人的父亲一旦确定，就不再尝试其他候选人。Prolog 用截断 ! 表示：当执行到它时，冻结当前已经做出的选择，丢弃之后的选择点。

截断常用在规则体里，用来告诉引擎：此处之前的选择已经确定，不要再回来尝试其它子句。比如 p(X) :- q(X), !, r(X). 当 q(X) 成功后就执行 !，后续 r(X) 即使失败也不会再尝试其它 p 子句。

否定即失败（negation as failure）是另一个重要机制。\+ G 表示“如果能证出 G 就失败，如果证不出 G 就成功”。它基于封闭世界假设：知识库里没有证据，就默认不成立。可以写成：

注意，截断能大幅提升性能，但也可能把本应找到的答案剪掉；否定同样依赖知识库的完整程度。档案库中这一切都很直观：“盖棺定论”的截断和“查无此证”的否定，都是带着前提的高效工具，用错就会误判。

AI 应用场景

Python 演示

#!/usr/bin/env python3# -*- coding: utf-8 -*- from itertools import count FACTS = [    ("parent", "amy", "bob"),    ("parent", "bob", "cara"),    ("parent", "cara", "dan"),] RULES = [    (("ancestor", "?x", "?y"), [("parent", "?x", "?y")]),    (("ancestor", "?x", "?y"), [("parent", "?x", "?z"), ("ancestor", "?z", "?y")]),] _counter = count(1) def is_var(t):    return isinstance(t, str) and t.startswith("?") def walk(t, env):    while is_var(t) and t in env:        t = env[t]    return t def unify(a, b, env):    a = walk(a, env)    b = walk(b, env)    if a == b:        return env    if is_var(a):        env[a] = b        return env    if is_var(b):        env[b] = a        return env    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b):        for x, y in zip(a[1:], b[1:]):            m = unify(x, y, env)            if m is None:                return None        return env    return None def rename(t, c):    if is_var(t):        return t + "_" + str(c)    if isinstance(t, tuple):        return tuple(rename(x, c) for x in t)    return t def prove(goals, env):    if not goals:        yield env        return    goal, rest = goals[0], goals[1:]    for fact in FACTS:        m = unify(goal, fact, env)        if m is not None:            yield from prove(rest, m)    for head, body in RULES:        c = next(_counter)        h = rename(head, c)        b = [rename(x, c) for x in body]        m = unify(goal, h, env)        if m is not None:            yield from prove(b + rest, m) def solve(query):    seen = set()    for env in prove([query], {}):        key = tuple(sorted(env.items()))        if key not in seen:            seen.add(key)            yield env if __name__ == "__main__":    for env in solve(("ancestor", "amy", "?x")):        print(env["?x"])

1. FACTS = [用元组模拟 Prolog 事实表，每个三元组是一条亲子断言。
2. RULES = [模拟规则：第一条直接证明祖先是父母，第二条通过中间人递归。
3. def unify(a, b, env):合一函数，返回新的绑定或 None，处理变量和常量的双向匹配。
4. if isinstance(a, tuple) and isinstance(b, tuple):递归比较复合项的每个参数，相当于比对谓词的内部结构。
5. for fact in FACTS:遍历事实数据库，逐个尝试合一。
6. for head, body in RULES:尝试用规则匹配目标，再证明规则体。
7. yield from prove(b + rest, m)把规则体子目标加入待证明队列，执行深度优先搜索与回溯。
8. if __name__ == "__main__":程序入口，运行查询并打印所有祖先答案。

常见误区

面试题