Lean 4 形式化證明入門:從安裝到第一條定理

Lean 4 是能讓電腦逐行檢查數學證明的語言。本文在 2 vCPU/7 GB 機器實測:elan 安裝後工具鏈 3.1 GB,lake new 建專案、冷編譯 1.68 秒、暖編譯 1.01 秒,並用 #print axioms 抓出 sorry 作弊、用四個真實錯誤訊息示範修法。

  • Dennis
  • 8 分鐘閱讀
Lean 4 形式化證明入門:從安裝到第一條定理

Lean 4 是「寫下證明、電腦逐行檢查」的程式語言:定理寫錯一個字元就編譯不過,沒有模糊空間。本文從零開始,在 2 核心/7 GB 的 VPS 上實測安裝、建專案、證明五條定理,並用 #print axioms 驗證自己的證明沒有作弊——全部指令與輸出都是實際跑過的。

為什麼現在值得花兩小時學

2026 年 11 月 20 日,Anthropic 數學家 Levent Alpöge 公布了一份 1,700 萬行的 Lean 證明,社群在一天內用多個獨立 kernel 確認「邏輯成立」——這是黎曼猜想 167 年來第一次有機器可檢查的版本(見〈黎曼猜想 Lean 證明通過〉)。

這件事的意義不只是數學。它證明了一件事:當結論重要到不能只靠信任時,形式化驗證是目前唯一能讓陌生人在幾小時內獨立複驗的方法。同一套邏輯現在用在晶片設計、智慧合約、密碼協定的正確性證明,以及 AI 推論的可驗證性(見〈Anthropic FlashProve:zkSNARK 證明 AI 回覆來自哪個模型〉)。

不用成為數學家也能入門。下面每一步都能在筆電或小型 VPS 上跑完。

第一步:安裝(elan 管版本,lake 管專案)

Lean 的官方安裝器是 elan,它同時管理 Lean 版本與 lake(建置工具,地位類似 Cargo)。

# 1. 下載安裝腳本(先存檔再執行,不要 curl | sh)
curl -sL -o /tmp/elan-init.sh \
  https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh

# 2. 執行,-y 表示全自動、預設安裝 stable 版
sh /tmp/elan-init.sh -y

# 3. 確認版本
~/.elan/bin/lean --version
~/.elan/bin/lake --version

實測輸出(2026-11-21):

Lean (version 4.36.0, x86_64-unknown-linux-gnu, commit 611c117bfaf7b7ae1cfcf246ce6fba31e8f509e9, Release)
Lake version 5.0.0-src+611c117 (Lean version 4.36.0)

有兩個成本要先知道:

項目實測值說明
安裝後總體積3.1 GB(~/.elan)含工具鏈、標準庫、原始碼;比 Node 或 JDK 大一個量級
安裝時間約 1–2 分鐘主要卡在下載 toolchain 壓縮檔
需要的系統x86_64 Linux/macOS/Windows官方有 ARM64 版本,但部分套件支援較慢

如果之後要加 Mathlib(Lean 的數學標準庫),體積與編譯時間會再往上跳一個量級,後面會說明什麼時候該碰它。

第二步:建專案

lake new lean_demo_1121
cd lean_demo_1121

產生的檔案不多,值得逐一看過:

lean-toolchain              # 這一行決定用哪個 Lean 版本
lakefile.toml               # 專案設定:name / defaultTargets / lean_lib / lean_exe
LeanDemo1121.lean           # 匯入入口(import LeanDemo1121.Basic)
LeanDemo1121/Basic.lean     # 放定理的地方
Main.lean                   # 可執行檔的 main
.github/workflows/lean_action_ci.yml   # 自動幫你建了 CI

lean-toolchain 內容只有一行,這是 Lean 生態的關鍵設計——版本跟著專案走:

leanprover/lean4:v4.36.0

別人在 2027 年 clone 這個專案,elan 會自動下載 v4.36.0,不會因為他的預設版本比較新就編譯失敗。這也是為什麼「這份證明能不能重現」在 Lean 世界是可回答的問題。

第三步:第一條定理(定義即證明)

打開 LeanDemo1121/Basic.lean,把內容換成下面這樣(namespace 只是整理命名空間):

namespace Demo

-- 1. 定義即證明:rfl 檢查兩邊定義上相等
theorem two_add_two : 2 + 2 = 4 := rfl

end Demo

執行:

lake build

rfl 是 reflexivity(自反性),意思是「左邊化簡後就是右邊」。2 + 2 與 4 在 Lean 的定義下是同一個項,所以不需要任何推理步驟。

這裡有個新手一定會踩的直覺陷阱:Lean 不接受「這很明顯」。2 + 2 = 5 會直接編譯失敗,錯誤訊息長這樣:

error: Not a definitional equality: the left-hand side
  2 + 2
is not definitionally equal to the right-hand side
  5
error: Type mismatch
  rfl
has type
  ?m.16 = ?m.16
but is expected to have type
  2 + 2 = 5

第四步:歸納法與自訂函式

接下來三個例子涵蓋日常會用到的三種證明手法。完整檔案:

namespace Demo

-- 1. 定義即證明
theorem two_add_two : 2 + 2 = 4 := rfl

-- 2. 歸納法:0 + n = n
theorem zero_add' (n : Nat) : 0 + n = n := by
  induction n with
  | zero => rfl
  | succ k ih => simp only [Nat.add_succ, ih]

-- 3. 自訂函式,再證明它的性質
def myAppend : List Nat → List Nat → List Nat
  | [], ys => ys
  | x :: xs, ys => x :: myAppend xs ys

theorem myAppend_assoc :
    ∀ (a b c : List Nat),
      myAppend (myAppend a b) c = myAppend a (myAppend b c)
  | [], _, _ => rfl
  | _ :: xs, b, c => by simp [myAppend, myAppend_assoc xs b c]

-- 4. 交給核心計算
example : (List.range 101).sum = 5050 := by decide

-- 5. 排中律需要 Classical.choice
theorem excluded_middle (p : Prop) : p ∨ ¬p := Classical.em p

end Demo

幾個重點:

  • by 進入 tactic 模式。induction n with 把目標拆成 zero 與 succ 兩個分支,ih 是歸納假設。
  • simp only [...] 是「只准用這幾條引理改寫」。這裡刻意不用全自動的 simp,原因見下方錯誤表——全自動的 simp 碰到某些引理會繞圈。
  • myAppend_assoc 用的是「模式匹配證明」:直接對 a 做案例分析,[] 分支是 rfl,x :: xs 分支遞迴呼叫自己。這比 tactic 模式更接近程式設計師的思考方式。
  • decide 把命題丟給核心的決策程序:(List.range 101).sum = 5050 可以完全由計算得出,所以不需要推理。

第五步:檢查自己的證明「有沒有作弊」

這是整篇文章最重要的一步,也是新聞裡那些獨立 kernel 在做的事的縮小版。

Lean 允許用 sorry 跳過任何證明,而且只給警告、照樣編譯成功。所以「編譯通過」不代表「證明完成」。解法是查公理依賴:

-- SorryDemo.lean
theorem cheat : 1 = 2 := by sorry
theorem honest : 1 + 1 = 2 := rfl

#print axioms cheat
#print axioms honest

實際輸出:

SorryDemo.lean:2:8: warning: declaration uses `sorry`
'cheat' depends on axioms: [sorryAx]
'honest' does not depend on any axioms

sorryAx 就是「這裡被跳過了」的鐵證。再看正式專案那五條定理的稽核結果(Audit.lean):

'Demo.two_add_two' does not depend on any axioms
'Demo.zero_add'' depends on axioms: [propext]
'Demo.myAppend_assoc' depends on axioms: [propext]
'Demo.excluded_middle' depends on axioms: [propext, Classical.choice, Quot.sound]
定理依賴公理意義
two_add_two無純定義計算
zero_add'propext用到了命題外延性,屬標準公理
myAppend_assocpropext同上
excluded_middlepropext、Classical.choice、Quot.sound用了排中律,等於引入選擇公理

Lean 的三個標準公理就是 propext、Classical.choice、Quot.sound。黎曼猜想那份證明的稽核結果正好也只有這三個——這就是為什麼社群敢說「沒有偷偷多假設一條公理」。

反過來說,任何時候看到 sorryAx、或看到自訂的 axiom,就知道這份證明的信任基礎變了。稽核只需要一行指令,沒有理由不看。

三個日常指令與實測數據

指令用途
lake build編譯整個專案(含執行檔)
lake env lean 檔案.lean只檢查單一檔案,適合快速迭代與看 #print axioms
lake exe 名稱執行 lakefile.toml 裡註冊的執行檔

實測環境為 2 vCPU/7 GB RAM 的 VPS(無 GPU),專案只依賴 Lean 核心、不含 Mathlib:

項目數字
冷編譯(刪掉 .lake 後重建,11 個 job)1.68 秒
暖編譯(無變更再跑一次)1.01 秒
產物大小(.lake)5.5 MB
工具鏈大小(~/.elan)3.1 GB
lake exe 執行結果2 + 2 = 4、myAppend [1,2] [3] = [1, 2, 3]

這也是為什麼 Lean 適合放進 CI:核心專案的建置成本不到兩秒,改一行就重跑一次完全可行。

四個真實踩到的錯誤與修法

以下都是這次實際撞到的訊息,不是想像的:

錯誤訊息原因修法
warning: Possibly looping simp theorem: Nat.add_succ + error: Tactic simp failed with a nested error: maximum recursion depth has been reached全自動 simp 把 Nat.add_succ 與其他加法引理互相改寫,繞圈到爆改用 simp only [Nat.add_succ, ih],指定只用這兩條
error: Unknown identifier hello改了 Basic.lean 拿掉 hello,但 Main.lean 還在引用兩個檔案一起改,或先 lake build 看是哪一個 target 失敗
error: Type mismatch ... has type ?m.16 = ?m.16 but is expected to have type 2 + 2 = 5用 rfl 證一個不成立的等式命題本身錯了;rfl 只能證定義上相等
沒有錯誤,但 #print axioms 出現 sorryAx用了 sorry 佔位把 sorry 補完;CI 應該把 sorry 當失敗

第四項最危險,因為它不會讓建置失敗。實務做法是在 CI 加上 grep -r "sorry" --include="*.lean" . 或使用 #print axioms 稽核關鍵定理。

Mathlib:什麼時候該碰、什麼時候別碰

Mathlib 是 Lean 的數學標準庫(實數、代數、拓撲、數論、zeta 函數都在裡面)。黎曼猜想那份證明的陳述直接引用 Mathlib 既有的 RiemannHypothesis 定義,這也是「陳述正確」這一關能成立的原因——不必信任作者自己寫的定義。

但對入門者,建議先不要加 Mathlib:

情境建議
學語法、寫小定理只用核心,編譯 1–2 秒
需要實數/微積分/線代加 Mathlib,第一次建置以小時計
只是要驗證別人的證明用官方的 .olean cache,不要自己從原始碼編

加 Mathlib 的方式是在 lakefile.toml 加上依賴並執行 lake update,之後第一次 lake build 會下載並編譯大量檔案。這是新手最常誤判「Lean 很慢」的原因——慢的是 Mathlib,不是 Lean 本身。

學習路線(依投入時間排序)

  1. 兩小時:跑完本文五條定理,搞懂 rfl、by、induction、simp only、decide。
  2. 一週:把日常寫的函式中「一定有 bug 風險」的那幾個改寫成 Lean(排序、區間運算、金額計算),證明它的性質。
  3. 一個月:讀 Mathlib 的命名慣例與 simp 引理標註(@[simp]),開始能讀懂別人的證明。
  4. 長期:挑一個真正關心的規格(密碼協定、狀態機、權限模型)做形式化。

形式化證明的價值不在證明誰比較聰明,而在「讓不同意的人也能獨立確認」。這也是為什麼一份 1,700 萬行的 Lean 檔案,可以在一天內被陌生人驗到「邏輯沒有漏洞」——換成人類文字稿,940 頁的版本八小時後就被回報有問題。

站內延伸閱讀

原始出處

  • Lean 4 官方文件:https://lean-lang.org/documentation/
  • Lean 社群部落格(黎曼猜想認證聲明):https://leanprover-community.github.io/blog/posts/riemann-hypothesis/
  • Mathlib 文件中的 RiemannHypothesis 定義:https://leanprover-community.github.io/mathlib4_docs/Mathlib/NumberTheory/LSeries/RiemannZeta.html
  • MIT 驗證頁(想看完整驗證清單):https://math.mit.edu/~drew/grh/

本文所有版本號、體積、編譯時間皆為 2026-11-21 在 2 vCPU/7 GB VPS 上的實測值;Lean 與 Lake 版本為 4.36.0/5.0.0。

📬 訂閱 most.tw 電子報

每週精選 AI 工具教學與技術乾貨,直接送到你的信箱。免費、隨時可退訂。

訂閱即表示同意收到 most.tw 電子報,隨時可一鍵退訂。

💬 有問題想討論?加 LINE 聯絡我

歡迎透過 LINE 官方帳號直接留言,我會盡快回覆你的問題。

加入 LINE 好友