跳到主内容
快讯直播
AI智模界
教程

给 Lean 证明仓库加三道 CI 门禁

这篇能做出什么

假设有一个公开仓库,声称用 Lean 4 给出了黎曼猜想的形式化证明。仓库里有一个出口定理:

```lean

-- RiemannHypothesis/Main.lean

theorem riemann_hypothesis : RiemannHypothesis := by

...

```

lake build 通过,README 写着“已机器验证”。问题是:编译通过不等于证明成立。下面几种情况都能让 lake build 一路正常通过:

```lean

-- 情况一:直接 sorry

theorem riemann_hypothesis : RiemannHypothesis := by

sorry

-- 情况二:自造公理,把结论当假设

axiom rh_axiom : RiemannHypothesis

theorem riemann_hypothesis : RiemannHypothesis := rh_axiom

-- 情况三:用 native_decide 引入编译器信任

theorem riemann_hypothesis : RiemannHypothesis := by

native_decide

```

这三种在人类审稿时都容易被漏掉,尤其情况二藏在几千行文件的中间时。

这篇教程要搭的是一条 PR 触发的流水线,把“已验证”拆成四个可自动检查、可留档的结论:

1. 能编译:lake build 通过。

2. 无 sorry:全仓库(白名单外)不出现 sorry / admit / 自造 axiom。

3. 公理封闭:出口定理的公理依赖是白名单的子集,典型白名单是 propext、Classical.choice、Quot.sound。

4. 可独立复现:换一台干净的机器、从锁定的依赖清单重建,得到同一份审计结论。

最终产出是一份 audit-report:里面写着 commit、toolchain、依赖清单哈希、每个出口定理依赖了哪些公理。任何一次“证明被削弱”的改动,都会在这份报告上留下痕迹。

前置条件清单

  • 一个 Lean 4 + Lake 的仓库,已经有 lean-toolchain 和 lake-manifest.json 两个文件并提交进版本库。
  • 本地能跑通 lake build,构建时间在可接受范围内(依赖 Mathlib 的项目建议先用官方预编译缓存)。
  • 有仓库 CI 的修改权限(下面以 GitHub Actions 为例,命令本身在 GitLab CI、Jenkins、本地脚本里通用)。
  • 知道自己的“出口定理”是哪些——通常是 README 里声称的那个主结论,加上一两个关键推论。
  • 已安装 bash、grep、python3。不引入任何额外第三方工具,脚本越少越容易审计。

目录结构约定成这样,后面所有命令都基于它:

```text

.

├── lean-toolchain

├── lakefile.lean

├── lake-manifest.json

├── RiemannHypothesis/

│ └── Main.lean

├── audit/

│ ├── Axioms.lean

│ └── expected-theorems.txt

└── scripts/

├── check_forbidden.sh

├── check_axioms.py

└── reproduce.sh

```

第一步:锁死工具链与依赖版本

复现的前提是“同样的输入”。Lean 项目有两个输入源:工具链和依赖。

lean-toolchain 里写的是一行工具链标识,具体格式和可用版本以 Lean 官方文档当前版本为准。这个文件必须提交,CI 第一步就打印它,让日志里留下证据。

lake-manifest.json 记录每个依赖的具体 commit。它必须提交,而且任何一次 PR 都不能悄悄改它。CI 里加这一步:

```yaml

  • name: 依赖未漂移

run: git diff --exit-code -- lake-manifest.json

```

如果有人跑了 lake update 并顺手提交,这里会红。要升依赖,单独开一个 PR,让 manifest 的变更在 diff 里被单独审视——这是把“依赖升级”和“证明修改”两件事拆开。

第二步:静态扫描 sorry 与危险关键字

新建 scripts/check_forbidden.sh:

```bash

#!/usr/bin/env bash

扫描 Lean 源码中的未完成证明与绕过手段。

用法: bash scripts/check_forbidden.sh [仓库根目录]

set -euo pipefail

ROOT="${1:-.}"

REPORT="$(mktemp)"

LIST="$(mktemp)"

trap 'rm -f "$REPORT" "$LIST"' EXIT

收集待扫描文件:排除构建产物与审计目录

find "$ROOT" -name '*.lean' \

-not -path '*/.lake/*' \

-not -path '*/audit/*' \

-print > "$LIST"

关键字模式:

sorry / admit 未完成证明

行首 axiom 自造公理

native_decide 引入编译器信任

@[implemented_by] 用实现替换定义

unsafe / partial 逃出逻辑内核

PATTERN='\b(sorry|admit)\b|^[[:space:]]*axiom[[:space:]]|native_decide|@\[implemented_by\]|^[[:space:]]*(unsafe|partial)[[:space:]]'

found=0

while IFS= read -r f; do

if grep -nE "$PATTERN" "$f" >> "$REPORT"; then

found=1

fi

done < "$LIST"

if [ "$found" -ne 0 ]; then

echo "== 发现被禁止的构造 =="

cat "$REPORT"

echo

echo "如果确属已知欠账,请把文件路径写进 scripts/sorry-allowlist.txt 并说明理由。"

exit 1

fi

echo "OK: 未发现 sorry / admit / 自造 axiom / native_decide"

```

白名单文件 scripts/sorry-allowlist.txt 只放路径和理由,比如:

```text

每行一个路径,后面跟 # 和理由。

定期清理,只减不增。

RiemannHypothesis/Experimental/Scratch.lean # 探索性草稿,未参与主定理

```

同时把 Experimental/ 目录从扫描中排除。白名单文件本身要设 CODEOWNERS 保护,否则下一个人直接往这里加一行就绕过了门禁。

这一步的输出是给人看的:哪一行、什么关键字。它很快,几秒钟出结果,适合放在构建之前,让人早点拿到反馈。

第三步:公理白名单审计

静态扫描会漏东西——宏生成的项、上游依赖里的 sorry、Classical.choice 之外的新公理。Lean 提供了权威出口:#print axioms。

新建 audit/Axioms.lean,把每个对外声称的定理都列一次:

```lean

import RiemannHypothesis.Main

/- 出口定理清单。

新增对外声称的结果时,必须在这里加一行,

并同步更新 audit/expected-theorems.txt。 -/

#print axioms RiemannHypothesis.riemann_hypothesis

```

再建 audit/expected-theorems.txt,一行一个完全限定名:

```text

RiemannHypothesis.riemann_hypothesis

```

新建 scripts/check_axioms.py:

```python

#!/usr/bin/env python3

"""解析 #print axioms 输出,比对白名单。"""

import pathlib

import re

import sys

ALLOWED = {"propext", "Classical.choice", "Quot.sound"}

def main(log_path: str, expected_path: str) -> int:

text = pathlib.Path(log_path).read_text(encoding="utf-8")

expected = {

line.strip()

for line in pathlib.Path(expected_path).read_text(encoding="utf-8").splitlines()

if line.strip() and not line.strip().startswith("#")

}

pat = re.compile(r"'([^']+)' depends on axioms:\s*\[([^\]]*)\]")

found = {}

for m in pat.finditer(text):

name = m.group(1)

axs = {a.strip() for a in m.group(2).split(",") if a.strip()}

found[name] = axs

if not found:

print("FAIL: 一条 #print axioms 输出都没解析到,检查 audit/Axioms.lean 是否被改动")

return 1

failed = False

1) 清单覆盖:防止有人删掉出口定理的审计行来“通过”

missing = expected - set(found)

if missing:

failed = True

for name in sorted(missing):

print(f"FAIL: 期望审计的定理没有出现在输出里: {name}")

2) 公理封闭

for name, axs in sorted(found.items()):

extra = axs - ALLOWED

if extra:

failed = True

print(f"FAIL {name}: 出现白名单外公理 {sorted(extra)}")

else:

print(f"OK {name}: {sorted(axs) or '无'}")

return 1 if failed else 0

if __name__ == "__main__":

sys.exit(main(sys.argv[1], "audit/expected-theorems.txt"))

```

本地跑一遍看看输出长什么样:

```bash

mkdir -p build

lake env lean audit/Axioms.lean 2>&1 | tee build/axioms.txt

python3 scripts/check_axioms.py build/axioms.txt

```

正常情况下的输出类似:

```text

OK RiemannHypothesis.riemann_hypothesis: ['Classical.choice', 'Quot.sound', 'propext']

```

如果有人把结论当公理塞进去,输出会变成:

```text

FAIL RiemannHypothesis.riemann_hypothesis: 出现白名单外公理 ['rh_axiom']

```

如果有人用了 sorry,输出会是:

```text

FAIL RiemannHypothesis.riemann_hypothesis: 出现白名单外公理 ['sorryAx']

```

注意 sorryAx 这个名字——它说明公理审计是第二道防线,即使 grep 被某种写法绕过了,这里也会拦住。

关于 native_decide:它会让定理依赖 Lean.ofReduceBool 一类的信任假设。是否把它加进白名单是个需要明确记录的决策,不能默认放行。若确实需要,就在 ALLOWED 里显式写上,并在 PR 里说明理由。

第四步:接进 CI

把上面三步拼成一条流水线。.github/workflows/proof-gate.yml:

```yaml

name: proof-gate

on:

pull_request:

push:

branches: [main]

schedule:

  • cron: "0 3 * * 1" # 每周重跑一次,防止工具链/缓存侧变化被忽略

jobs:

audit:

name: 构建 + 禁 sorry + 公理白名单

runs-on: ubuntu-latest

steps:

  • uses: actions/checkout@v4 # 版本以官方 Marketplace 当前版本为准
  • name: 安装 elan

安装脚本地址与参数以 Lean 官方安装文档为准

run: |

curl -sSf https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh | sh -s -- -y

echo "$HOME/.elan/bin" >> "$GITHUB_PATH"

  • name: 打印锁定的工具链

run: cat lean-toolchain

  • name: 拉取预编译缓存

未依赖 Mathlib 的项目可以删掉这一步

run: lake exe cache get

  • name: 构建

run: lake build

  • name: 依赖未漂移

run: git diff --exit-code -- lake-manifest.json

  • name: 禁 sorry / 危险关键字

run: bash scripts/check_forbidden.sh .

  • name: 公理白名单

run: |

mkdir -p build

lake env lean audit/Axioms.lean 2>&1 | tee build/axioms.txt

python3 scripts/check_axioms.py build/axioms.txt

  • name: 上传审计记录

if: always()

uses: actions/upload-artifact@v4

with:

name: audit-report

path: build/axioms.txt

```

if: always() 很关键:即使门禁失败,也要把那份 axioms.txt 传上来,失败时才有东西可看。

第五步:独立复现

前面几个 job 都在同一个 runner 上、用同一份缓存。真正要回答的问题是:换一台机器,能不能得到同样的结论?

新建 scripts/reproduce.sh:

```bash

#!/usr/bin/env bash

在一个全新副本里从零重建并复核。要求当前工作区干净。

set -euo pipefail

SRC="$(git rev-parse --show-toplevel)"

WORK="$(mktemp -d)"

trap 'rm -rf "$WORK"' EXIT

git clone --depth 1 "file://$SRC" "$WORK/repo"

cd "$WORK/repo"

echo "== commit =="

git rev-parse HEAD

echo "== toolchain =="

cat lean-toolchain

未依赖 Mathlib 的项目删掉这一行

lake exe cache get

lake build

bash scripts/check_forbidden.sh .

mkdir -p build

lake env lean audit/Axioms.lean 2>&1 | tee build/axioms.txt

python3 scripts/check_axioms.py build/axioms.txt

echo "== 审计指纹 =="

sha256sum lean-toolchain lake-manifest.json audit/expected-theorems.txt build/axioms.txt

```

在 CI 里加一个独立 job,故意不复用任何 actions/cache:

```yaml

reproduce:

name: 独立复现

runs-on: ubuntu-latest

needs: audit

steps:

  • uses: actions/checkout@v4
  • name: 安装 elan

run: |

curl -sSf https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh | sh -s -- -y

echo "$HOME/.elan/bin" >> "$GITHUB_PATH"

  • name: 从干净副本重建并复核

run: bash scripts/reproduce.sh

```

这里有一点要说清楚:不要追求二进制级可复现。.olean 文件可能嵌入构建路径等信息,两次构建的哈希不一定相同。要对比的是审计结论——“哪些定理、依赖哪些公理、用了哪个 toolchain、哪个依赖清单”。这几项是确定性的,跨机器应该完全一致。

更严格的做法是让一位外部复核者在自己机器上跑 bash scripts/reproduce.sh,把最后那几行 sha256sum 贴到 PR 里。这就是“独立复现”的实质:不是相信 CI,而是相信任何人重复执行同一份脚本得到同一份输出。

常见坑与排错

grep 误伤注释。 Lean 的注释里写“这里先 sorry 一下”也会被扫到。别急着改正则——Lean 有嵌套块注释,正则剥离注释很容易出错。更省事的做法是把注释改成“未完成”,顺便让注释也干净。

白名单越加越长。 一旦允许“临时加一行”,半年后白名单会变成绕过门禁的通道。给白名单文件加 CODEOWNERS,要求两人 review,并在 CI 里打印白名单行数。

#print axioms 的输出格式变了。 不同 Lean 版本的措辞可能有微调。解析脚本的正则一旦匹配不到,代码里是直接报错退出而不是静默通过——这个设计别改。宁可门禁误报,也不要漏报。

删掉审计行来“通过”。 这是最容易被忽略的绕过路径:把 audit/Axioms.lean 里那行 #print axioms 注释掉,脚本就没结果可查。所以 check_axioms.py 里做了 expected - found 的覆盖检查,缺一个就判失败。

缓存导致“假复现”。 如果复现 job 复用了构建缓存,它其实什么都没验证。独立 job 里不要挂 actions/cache;lake exe cache get 拉的是官方分发的预编译产物,算可信第三方,可以保留,但日志里要能看到这一步执行了。

CI 超时。 依赖 Mathlib 的项目全量构建可能很久。把静态扫描拆到单独的轻量 job 里先跑,让人在三分钟内拿到 sorry 的反馈,再去等构建。

native_decide 悄悄进来。 它在大文件里毫不起眼。要么在静态扫描阶段拦住,要么在公理阶段让它以 Lean.ofReduceBool 的形式暴露出来——两条路都留着。

只在 main 上跑。 门禁的价值在于拦 PR。on: pull_request 必须有,push: main 只是兜底。

下一步建议

  • 把审计报告存档成时间线。 每次 main 分支构建成功后,把 axioms.txt 加上 commit 号提交到 audit/reports/。半年后回头看,“这个定理的公理依赖什么时候变过”是有答案的。
  • 加更多 lint。 set_option autoImplicit false 可以禁掉隐式变量自动绑定,减少“笔误也能编译”的空间;Lean 也支持把 warning 当 error 处理,具体写法以官方文档为准。这类检查便宜,收益稳定。
  • 做声明与实现的对应检查。 在 README 或 blueprint 里声称的定理名,和 audit/expected-theorems.txt 里的名字做一致性校验,防止“README 说证了 A,代码里证的是 A'”。
  • 定期重跑。 加一条每周的定时任务,用当前 toolchain 重跑全流程。工具链、上游依赖、CI runner 环境都会变,定时重跑是发现“睡着的失败”的廉价手段。
  • 把门禁脚本抽成可复用模板。 这套 check_forbidden.sh + check_axioms.py 不依赖具体项目,任何 Lean 仓库都能直接拿走用。真正需要按项目定制的,只有 ALLOWED 集合和出口定理清单两处。

AI 生成本文由 AI 基于公开信息自动生成,仅供参考。