---
id: "authored/776cfced-a924-402f-9929-72e66972ad62"
title: "리만가설 증명은 어떻게 컴파일될까?"
description: "명제는 타입이고 증명은 값이라는 Lean의 구조를 작은 예제부터 따라가며, 리만가설 제출물과 공개 검증 기록을 읽어 본다."
kind: "record"
published: "2026-11-21T05:02:11.752Z"
tags: ["Lean","형식증명","리만가설"]
url: "https://www.readiz.com/records/riemann-hypothesis-lean-proof-for-programmers/"
markdownUrl: "https://www.readiz.com/records/riemann-hypothesis-lean-proof-for-programmers/index.md"
recordFolder: "공부/수학"
folderUrl: "https://www.readiz.com/records/?folder=%EA%B3%B5%EB%B6%80%2F%EC%88%98%ED%95%99"
---

# 리만가설 증명은 어떻게 컴파일될까?

2026년 11월 20일, 수학자 Levent Alpöge는 Claude와 함께 리만가설의 증명을 찾았다고 발표했다. 공개한 것은 Lean으로 작성된 형식증명이다. 사람에게 설명하기 위한 글과 증명의 단순화는 앞으로 이어 가겠다고 했다. [발표문 PDF](https://alpo.ge/remark.pdf)

프로그래머 입장에서 눈에 들어오는 대목은 따로 있다. **이번 제출물은 수학 라이브러리 Mathlib에 이미 있던 `RiemannHypothesis`를 증명 대상으로 사용했고, 그 증명을 포함한 전체 소스가 오류 없이 컴파일됐다는 기록이 공개됐다.** [Andrew Sutherland의 검증 기록](https://math.mit.edu/~drew/grh/)

수학의 증명이 컴파일된다는 말은 처음 들으면 이상하다. C++ 코드가 컴파일됐다고 해서 알고리즘까지 맞는 것은 아니니까. Lean에서는 타입에 담는 내용이 다르다. `int`처럼 값의 종류를 적을 수도 있지만, ‘모든 자연수 n에 대해 0 + n = n이다’라는 명제 자체를 타입으로 적을 수도 있다. 그러면 그 타입에 맞는 값을 만드는 일이 증명이 된다.

이 구조를 이해하면 리만가설 소스의 가장 위에 있는 한 줄도 읽을 수 있다. 덧셈부터 시작해 실제 제출물까지 따라가 보자. 이 글의 대규모 빌드와 재검사 결과는 Sutherland가 공개한 기록을 인용하며, 기준은 **2026년 11월 21일 오전 7시 5분 KST에 갱신된 현황**이다.

## 명제를 타입으로 적는다는 것

`n : Nat`은 자연수 타입의 값 n이 있다는 뜻이다. Lean에서는 같은 문법으로 `h : P`를 적는다. P가 명제라면 h는 P의 증명이다.

| 표현               | 읽는 방법                        |
| ---------------- | ---------------------------- |
| `P : Prop`       | P는 명제다.                      |
| `h : P`          | h는 P의 증명이다.                  |
| `P → Q`          | P의 증명을 받아 Q의 증명을 제공한다.       |
| `P ∧ Q`          | P와 Q의 증명을 함께 갖는다.            |
| `∀ n : Nat, P n` | 임의의 자연수 n에 대해 P n의 증명을 제공한다. |

`Prop`에는 명제가 들어간다. ‘문제를 표현하는 타입’과 ‘그 문제를 해결한 증거’를 같은 언어 안에서 다루는 것이다. 이런 연결을 Curry–Howard 대응이라고 부른다. [Lean 공식 교재: 명제와 증명](https://lean-lang.org/theorem_proving_in_lean4/Propositions-and-Proofs/)

가령 `P → Q`를 증명하려면 P의 증거가 주어졌을 때 Q의 증거를 만드는 방법을 내놓으면 된다. 함수의 입력과 출력으로 읽으면 익숙하다. `∀ n : Nat, P n`에서는 입력 n에 따라 요구되는 결과의 타입도 `P n`으로 달라진다. 이처럼 입력값에 의존하는 타입을 쓰면 ‘모든 n에 대한 성질’을 함수의 타입으로 표현할 수 있다. [보편 명제와 의존 함수](https://lean-lang.org/theorem_proving_in_lean4/Quantifiers-and-Equality/)

여기서 필요한 값은 명제에 맞는 논리적 증거다. `Bool` 변수에 `true`를 넣는 것과는 역할이 다르다. `h : P`를 제출하면 Lean은 h의 구조를 검사해서 정말 P의 증거가 되는지 확인한다.

## 증거 두 개의 순서를 바꾸면 증명이 된다

‘P와 Q가 모두 참이면, Q와 P도 모두 참이다’를 코드로 적어 보자.

```lean
theorem swap_and (P Q : Prop) : P ∧ Q → Q ∧ P :=
  fun h => And.intro h.right h.left
```

`theorem` 뒤에는 정리의 이름이 온다. 콜론 뒤의 `P ∧ Q → Q ∧ P`가 증명할 명제이고, `:=` 오른쪽이 그 증명이다.

입력 h에는 두 증거가 들어 있다. `h.left`는 P의 증거, `h.right`는 Q의 증거다. `And.intro`는 두 증거를 묶는 생성자다. Q의 증거를 먼저 넣고 P의 증거를 나중에 넣었으니 결과는 `Q ∧ P`가 된다. 필요한 재료를 받아 요구된 순서로 조립하는 함수 하나로 증명이 끝난다.

같은 증명을 절차로 쓸 수도 있다.

```lean
theorem swap_and_tactic (P Q : Prop) : P ∧ Q → Q ∧ P := by
  intro h
  exact And.intro h.right h.left
```

`intro h`는 주어진 증거에 이름을 붙이고, `exact`는 현재 목표에 맞는 증거를 제출한다. `by` 뒤에 오는 이런 명령을 전술(tactic)이라고 부른다. 긴 증명에서는 목표를 나누거나 기존 정리를 적용하는 전술을 이어 쓴다.

전술은 최종적으로 검사할 \*\*증명 항(proof term)\*\*을 만든다. 위 예제에서는 두 증거를 뒤집어 묶는 함수가 그 증명 항이다. 사람이 함수 표현을 직접 쓰든 전술로 구성하든, 커널이 받는 것은 선언된 타입에 맞아야 하는 증거다. [Lean 공식 교재: 전술](https://lean-lang.org/theorem_proving_in_lean4/Tactics/)

## 무한히 많은 자연수를 유한한 코드로 다루기

이번에는 모든 자연수 n에 대해 `0 + n = n`을 증명해 보자. 먼저 명제에 이름을 붙인다.

```lean
def ZeroAddStatement : Prop :=
  ∀ n : Nat, 0 + n = n
```

여기까지는 풀 문제를 적은 것이다. `ZeroAddStatement`라는 타입의 증거를 제공해야 증명이 완성된다.

```lean
theorem zeroAddProof : ZeroAddStatement := by
  unfold ZeroAddStatement
  intro n
  induction n with
  | zero =>
      rfl
  | succ k ih =>
      change Nat.succ (0 + k) = Nat.succ k
      exact congrArg Nat.succ ih
```

`unfold`는 방금 붙인 이름을 펼치고, `intro n`은 임의의 자연수 하나에 n이라는 이름을 붙인다. 다음의 `induction n`이 수학적 귀납법이다. 자연수의 구조에 따라 목표를 0과 그다음 수의 경우로 나눈다.

0인 경우에는 `0 + 0 = 0`을 보이면 된다. 덧셈의 정의를 계산하면 양쪽이 같아진다. `rfl`은 이렇게 정의에 따라 같은 식이 되는 등식을 증명한다.

다음 분기의 `Nat.succ k`는 k의 다음 자연수, 즉 k + 1이다. `ih`에는 `0 + k = k`라는 귀납 가정이 들어 있다. 이 증거를 이용해 `0 + (k + 1) = k + 1`을 만들어야 한다.

Lean의 자연수 덧셈은 두 번째 인자를 따라 재귀적으로 정의된다. 그래서 목표를 정의에 따라 펼치면 다음과 같다.

```text
Nat.succ (0 + k) = Nat.succ k
```

코드의 `change`가 목표를 이 형태로 드러낸다. 이제 귀납 가정 `0 + k = k`의 양변에 `Nat.succ`를 적용하면 된다. `congrArg Nat.succ ih`가 바로 그 증거다. 같은 값에 같은 함수를 적용했으므로 결과도 같다는 규칙을 사용했다. [귀납법과 재귀의 연결](https://lean-lang.org/theorem_proving_in_lean4/Induction-and-Recursion/)

이 증명에는 자연수를 끝까지 대입하는 루프가 없다. 0에서의 증거 하나와, k의 증거를 k + 1의 증거로 바꾸는 일반적인 방법이 있다. 자연수의 귀납 원리가 이 두 부분을 모든 자연수에 대한 증명으로 연결한다. 유한한 코드로 무한한 범위의 명제를 다루는 이유다.

문제와 증거의 관계도 코드에서 확인할 수 있다.

```lean
#check ZeroAddStatement  -- 명제 자체의 타입: Prop
#check zeroAddProof      -- 증거의 타입: ZeroAddStatement
```

`ZeroAddStatement`는 명제이고, `zeroAddProof`는 그 명제의 증거다. 이 둘을 구별해 두면 뒤의 리만가설 선언도 같은 구조로 읽힌다.

## Lean이 컴파일하면서 검사하는 것

Lean 소스에는 생략된 타입, 편의 문법, 전술이 들어 있다. 이런 코드를 커널이 다루는 작은 핵심 언어의 항으로 바꾸는 과정을 정교화(elaboration)라고 한다. 커널은 그 결과가 타입 이론의 규칙을 따르는지 검사한다. [Lean의 처리 단계](https://lean-lang.org/doc/reference/latest/Elaboration-and-Compilation/)

![Lean 소스가 정교화와 전술을 거쳐 증명 항이 되고, 커널이 명제의 타입과 일치하는지 검사하는 흐름](https://www.readiz.com/assets/authored/776cfced-a924-402f-9929-72e66972ad62/3d9910a9-08fc-4785-bdcd-5bd929775c68.webp)

*Lean 공식 문서의 [처리 단계](https://lean-lang.org/doc/reference/latest/Elaboration-and-Compilation/)를 바탕으로 직접 그린 도식. P는 증명할 명제이고 t는 제출할 증거다.*

사람과 AI는 증명을 찾고, 전술은 증명 항을 구성하고, 커널은 그 항을 검사한다. 귀납법이나 재귀를 편한 문법으로 적었더라도 변환 결과는 다시 커널 검사를 받는다.

이 구조에서 ‘컴파일 성공’이라는 표현이 증명과 연결된다. 실행 파일을 만들기 앞서, 제출한 증거가 명제의 타입에 맞는지 확인하는 단계가 있기 때문이다. 일반적인 C++ 함수의 반환형 `int`는 정수 하나를 내놓으라는 요구다. `∀ n : Nat, 0 + n = n`이라는 타입은 모든 자연수에 대한 등식의 증거를 요구한다. 타입에 적어 둔 요구사항의 깊이가 다르다.

다만 Lean은 작성 중인 증명을 다루는 기능도 제공한다. `sorry`로 비워 둔 자리나 별도 공리도 환경 안에 들어올 수 있으므로, 제출된 증명의 검증에는 공리 의존성 확인까지 포함된다. 실제 리만가설 기록에서 빌드 외에 여러 검사를 수행한 이유가 여기에 있다.

## Mathlib에는 이미 리만가설이라는 타입이 있었다

리만가설은 리만 제타 함수의 비자명한 영점이 모두 실수부 1/2인 직선 위에 놓인다는 명제다. ‘영점’은 함수값이 0이 되는 입력을 말한다. 복소수를 $s = \sigma + it$로 쓰면, 이 영점들에 대해 $\sigma = 1/2$라는 주장이다.

컴퓨터에 이 문제를 넘기려면 복소수, 제타 함수, 영점과 실수부가 먼저 정의돼 있어야 한다. 그 바탕을 제공하는 것이 Lean의 수학 라이브러리 Mathlib다. 이번 제출물이 고정한 Mathlib 커밋은 `0df444a360eaa60ab8c11dca51a86af692955474`이고, 그 버전의 `Mathlib/NumberTheory/LSeries/RiemannZeta.lean`에는 이미 `RiemannHypothesis : Prop`가 정의돼 있다. [의존성 설정](https://github.com/leanprover-community/riemann-hypothesis/blob/main/lake-manifest.json), [해당 버전의 정의](https://github.com/leanprover-community/mathlib4/blob/0df444a360eaa60ab8c11dca51a86af692955474/Mathlib/NumberTheory/LSeries/RiemannZeta.lean)

정의의 각 조건을 풀어 쓰면 다음과 같다.

| 코드의 조건                       | 의미                               |
| ---------------------------- | -------------------------------- |
| `s : ℂ`                      | 임의의 복소수 s를 잡는다.                  |
| `riemannZeta s = 0`          | s에서 제타 함수의 값이 0이다.               |
| `¬∃ n : ℕ, s = -2 * (n + 1)` | −2, −4, −6, …에 놓이는 자명한 영점을 제외한다. |
| `s ≠ 1`                      | 제타 함수에 극점이 있는 1을 제외한다.           |
| 결론 `s.re = 1 / 2`            | s의 실수부가 1/2임을 요구한다.              |

Mathlib는 제타 함수를 모든 복소수 입력에 값을 돌려주는 함수로 표현한다. 수학적으로 극점이 있는 1에서의 값을 일반적인 제타 함수값처럼 사용하지 않도록, 명제에 `s ≠ 1`이라는 조건을 적어 둔 것이다.

Mathlib 환경에서는 다음 명령으로 이 문제의 정의를 볼 수 있다.

```lean
import Mathlib

#check RiemannHypothesis
#print RiemannHypothesis
```

`#check`는 이름의 타입을, `#print`는 그 이름으로 정의된 내용을 보여 준다. 앞에서 `ZeroAddStatement`라는 문제를 정의했던 단계에 해당한다. 라이브러리는 해결해야 할 명제를 이미 표현해 놓았고, 증명자는 그 명제의 증거를 제공해야 한다.

## 실제 제출물의 한 줄을 읽어 보기

공개된 `Main.lean`에는 이런 선언이 있다.

```lean
theorem riemannHypothesis : RiemannHypothesis := rhOfAll
```

*[공개된 Main.lean](https://github.com/leanprover-community/riemann-hypothesis/blob/main/src/Main.lean)의 최상위 정리 선언.*

이제 각 부분의 역할이 보인다. 소문자로 시작하는 `riemannHypothesis`는 새로 제공하는 정리의 이름이다. 대문자로 시작하는 `RiemannHypothesis`는 Mathlib에 있던 명제다. 오른쪽의 `rhOfAll`이 그 타입을 만족하도록 앞선 모듈들에서 구성한 증거다.

| 작은 예제              | 리만가설 제출물            | 역할            |
| ------------------ | ------------------- | ------------- |
| `ZeroAddStatement` | `RiemannHypothesis` | 증명해야 할 명제     |
| 귀납법으로 만든 증명 항      | `rhOfAll`           | 명제를 만족하는 증거   |
| `zeroAddProof`     | `riemannHypothesis` | 완성된 정리에 붙인 이름 |

최상위 선언은 다른 모듈에서 만들어 둔 증거를 연결한다. 함수 하나를 호출하는 코드가 짧아도 그 뒤에 큰 라이브러리가 있을 수 있는 것처럼, 이 한 줄 뒤에는 수많은 보조정리와 의존성이 있다.

목표가 어디서 왔는지도 공개 기록에 남아 있다. `Statements.lean`은 Mathlib를 가져오며, [공리 검사 로그](https://math.mit.edu/~drew/grh/audit.log)는 `RiemannHypothesis`가 Mathlib의 제타 함수 모듈에서, `riemannHypothesis`가 제출물의 `Main`에서 선언됐다고 보여 준다. 기존 라이브러리의 문제와 새 제출물의 증거가 연결되는 지점이다. [Statements.lean](https://github.com/Deicyde/riemann-hypothesis/blob/main/src/Statements.lean)

## 공개 검증 기록은 무엇을 확인했나

Sutherland의 현황에는 Lean과 Mathlib 4.33.1을 사용한 전체 175,187개 모듈의 컴파일이 오류 없이 끝났다고 적혀 있다. 같은 기록의 주요 결과를 읽으면 다음과 같다.

| 검사                                           | 2026년 11월 21일 07:05 KST 기준 공개 상태                |
| -------------------------------------------- | ----------------------------------------------- |
| 전체 175,187개 모듈 컴파일                           | 오류 없이 완료                                        |
| 주요 정리 5개의 공리 의존성                             | `propext`, `Classical.choice`, `Quot.sound`만 사용 |
| Mathlib와 종속 라이브러리의 `.olean` 파일               | 공식 캐시와 바이트 단위 일치                                |
| `leanchecker`의 모듈별 재검사                       | 전체 통과                                           |
| `lean4lean`의 모듈별 재검사                         | 전체 통과. 5개는 기본 연산 한도를 올려 재검사                     |
| 독립 검사기 `nanoda`, `con-leche`                 | 내보낸 전체 증명을 수락                                   |
| `con-leche --compare`의 명제 비교                 | 목표 정리 5개가 제출물로 정당화됨을 확인                         |
| 전체 `lake comparator` 실행과 내보낸 증명의 Lean 커널 재검사 | 진행 중                                            |

*표의 출처는 [Sutherland의 검증 현황](https://math.mit.edu/~drew/grh/)이다. 여기서 GRH는 디리클레 L함수에 대한 일반화 리만가설을 뜻한다.*

각 검사는 서로 다른 질문에 답한다.

공리 검사는 증명이 어떤 출발점에 기대는지 본다. `sorry`로 남긴 증명은 `sorryAx`에 의존할 수 있다. 이번 [로그](https://math.mit.edu/~drew/grh/audit.log)에서는 주요 정리의 의존성이 표에 적은 표준 공리 세 개로 한정된다. 환경에 등록된 모든 공리의 목록과 특정 정리가 실제로 사용하는 공리의 목록은 따로 출력돼 있다. 이 경우 읽어야 할 것은 해당 정리의 의존 목록이다.

명제 비교는 ‘무엇을 증명했는가’를 확인한다. 검증자가 신뢰하는 환경에 준비한 문제와 제출물이 증명한 명제를, 그 안에 사용된 정의까지 대조한다. 이름만 같은 명제를 찾는 것보다 강한 검사다. 다른 커널로 증명 항을 다시 확인하면 검사 구현 하나에 대한 의존도도 줄일 수 있다. [Lean 공식 문서: 증명 검증](https://lean-lang.org/doc/reference/latest/ValidatingProofs/)

해당 시점에 남아 있던 범위도 구체적이다. 검증 기록의 빌드는 샌드박스 밖에서 `lean`을 직접 호출했고, 일반적인 `lake build` 결과와의 비교는 77개 모듈 표본까지였다. 격리된 빌드에서 얻은 전체 결과와 내보낸 증명의 해시를 대조하는 작업도 남아 있었다. 따라서 기록이 뒷받침하는 판단은 **Mathlib로 적힌 목표 명제가 표준 공리들로부터 따라온다는 것을 여러 검사기가 확인했다**는 것이다. [검증 기록의 남은 항목](https://math.mit.edu/~drew/grh/#caveats)

## 증명을 찾는 일과 검사하는 일이 나뉜다

Alpöge는 자신이 접근 방향을 잡았고, 후반부에는 Claude가 제시한 아이디어가 자신의 이해를 앞서 갔다고 설명했다. 현재 논증은 매우 길며 앞으로 이를 이해하고 단순화해 설명하겠다는 것이 발표문의 입장이다. [발표문 PDF, 1\~2쪽](https://alpo.ge/remark.pdf)

증명을 찾는 작업에는 큰 목표를 작은 목표로 나누는 판단, 필요한 보조정리를 알아보는 능력, 실패한 접근을 바꾸는 탐색이 들어간다. 커널이 맡는 일은 그 탐색의 결과로 제출된 증거를 검사하는 것이다. 찾아내기 어려운 증명도 충분히 명시적인 형태로 주어지면, 그 논리적 연결을 별도의 프로그램에 검사시킬 수 있다.

작은 덧셈 예제에서도 구조는 같았다. 어떤 방식으로 귀납법을 떠올렸는지는 커널의 검사 대상이 아니다. 제출된 항이 `ZeroAddStatement`를 증명하는지가 검사 대상이다. 리만가설 제출물에서는 그 자리에 Mathlib의 `RiemannHypothesis`와 거대한 증명 항이 놓인다.

프로그래머에게 이 사건이 흥미로운 이유는 오래된 수학 문제에 **명세, 구현, 의존성, 검증**이라는 익숙한 구조가 드러나기 때문이다. 명제를 타입으로 정확히 적고 그 타입의 증거를 제공하면, 작성자와 별개의 프로그램이 논증을 다시 확인할 수 있다. 사람과 AI가 함께 만든 결과를 검증 가능한 산출물로 주고받는 방식이다. 이때 컴파일에 담긴 의미는, 수학적 요구사항을 만족하는 증거가 실제로 연결됐는지를 검사했다는 데 있다.

## 더 읽을 자료

- [Theorem Proving in Lean 4](https://lean-lang.org/theorem_proving_in_lean4/Propositions-and-Proofs/): 명제와 증명에서 시작해 전술과 귀납법으로 이어지는 공식 교재.
- [Validating a Lean Proof](https://lean-lang.org/doc/reference/latest/ValidatingProofs/): 공리 확인, 재검사, 목표 명제 비교의 역할을 설명하는 공식 문서.
- [리만가설 제출물](https://github.com/leanprover-community/riemann-hypothesis): `Main.lean`과 고정된 의존성에서 형식적 목표를 확인할 수 있는 소스.
- [공개 검증 기록](https://math.mit.edu/~drew/grh/): 검사 결과와 로그, 갱신 시각을 함께 제공하는 자료.
