Верификация гипотезы Римана в Lean: уроки для инженеров
Доказательство гипотезы Римана на 17 млн строк в Lean прошло независимые проверки. Чему системы формальных доказательств учат инженеров.

Самая дерзкая инженерная работа последнего времени — это не фреймворк, не база данных и не AI-агент. Это доказательство. Леван Альпёге опубликовал верификацию в Lean гипотезы Римана в виде библиотеки примерно на семнадцать миллионов строк кода. Уже через день распределённая группа волонтёров скомпилировала её, сверила финальную теорему с каноническим утверждением в Mathlib и перепроверила экспортированное доказательство несколькими независимыми ядрами, два из которых сами содержат машинно проверенные аргументы о том, что не могут принять ложное доказательство.
Мой контринтуитивный тезис, который я сейчас отстою, а потом частично пересмотрю: это самое важное событие в языках программирования за десятилетие, и почти никак не связано с теорией чисел. Гипотеза Римана здесь почти ни при чём. Важно то, что у нас теперь есть рабочий пример в масштабе настоящих исследований задачи, вокруг которой инженеры-программисты постоянно ходят, но так и не берутся за неё всерьёз: как построить артефакт настолько большой, что ни один человек не сможет его проверить вручную, но при этом проверенный настолько строго, что незнакомые люди готовы поставить на него свою профессиональную репутацию?
Что на самом деле означают семнадцать миллионов строк верификации в Lean
Lean построен на идее, которую Николаас де Брёйн разработал в конце 1960-х вместе с Automath — одной из первых систем для записи математики в виде, пригодном для машинной проверки. Сейчас эту идею называют критерием де Брёйна: система доказательств должна выдавать объекты доказательств, которые небольшая независимая программа-проверщик может проверить самостоятельно. Большая и умная часть системы — элаборатор, движок тактик, автоматизация, которая превращает человеческие скрипты доказательств в формальные объекты — намеренно не является доверенной. Это компилятор, а любой компилятор может содержать ошибки. Доверие сосредоточено в ядре, небольшой программе, которая полностью проверяет типы элаборированных доказательных термов по правилам логики.
Именно эта архитектура делает артефакт на семнадцать миллионов строк осмысленным. Это доказательство никто не читал. И никто не смог бы. По объёму оно сравнимо с крупным компонентом операционной системы, и в основном оно сгенерировано машиной и устроено под машину. Но процесс верификации обращается с ним так, как хорошая система сборки обращается со скомпилированным бинарником: десятки людей независимо скомпилировали библиотеку и получили тот же самый сырой файл экспорта доказательства, побайтово. Это герметичная, детерминированная сборка, которая выдаёт адресуемый по содержимому артефакт, и дальше начинается самое интересное, потому что проверяющие программы работают с артефактом, а не с исходниками.
Доказательство, которое нельзя прочитать, всё равно может быть доказательством, которому можно доверять. Именно в этой инверсии обычного код-ревью и вся суть истории.
Людям из мира софта стоит на минуту задуматься над этой инверсией. Наш стандартный механизм гарантий — человек, который открывает диф и хмурится. Это масштабируется примерно на несколько тысяч строк в неделю на одного ревьюера, после чего хмурый взгляд превращается в театр. Ответ сообщества Lean — перенести доверие вниз по стеку: доверять небольшому ядру, доверять разнообразию независимых переизложений этого ядра и рассматривать всё, что выше, сколько бы миллионов строк это ни было, как данные для проверки, а не как текст для чтения. Это не математический трюк. Это инженерная позиция.
Проблема утверждения: доказать правильную теорему
Первым сообщество проверило не доказательство, а утверждение. Аутсайдеры постоянно недооценивают именно эту часть, и именно здесь проекты формализации тихо умирают. Система доказательств с радостью позволит доказать неправильное утверждение с абсолютной строгостью: логике всё равно, что вы имели в виду. Классический игрушечный пример — верифицированная процедура сортировки, спецификация которой говорит, что результат упорядочен, но забывает добавить, что это перестановка входа. Пустой список прекрасно отсортирован. Доказательство проходит. Функция при этом мусорная.
Поэтому сертификат этой работы опирается на факт, который легко пропустить: утверждение RiemannHypothesis уже существовало в Mathlib, где его тщательно проверяли люди, которые действительно знают и аналитическую теорию чисел, и соглашения кодирования Lean — где могут находиться нули, как исключаются тривиальные нули, на чём вообще определена функция. Затем сообщество добавило файл, который изолирует именно это утверждение, импортирует только Mathlib, и с помощью двух независимых инструментов (comparator и con-leche --compare) подтвердило, что теорема из библиотеки Альпёге — это ровно то утверждение, а не почти совпадение, не определение-двойник с тихо отброшенной более слабой гипотезой. Я уже писал о том, что разрыв между спецификацией и реализацией — это место, где живут баги, и формальная математика — та область, где эта истина перестаёт быть постом в блоге и становится пунктом чек-листа с выделенными инструментами.
Посмотрите, насколько эта дисциплина необычна по меркам индустрии. Когда вы в последний раз видели команду, которая написала отдельный инструмент, единственная задача которого — доказать, что система делает именно то, что говорит контракт? Мы пишем тесты, которые выборочно проверяют контракт. Мы пишем сигнатуры типов, которые на него лишь намекают. Сообщество Lean построило компараторы, которые его идентифицируют. Если из всей этой истории вы возьмёте одну практику, возьмите именно эту: прежде чем радоваться тому, что машина проверила ваше доказательство, проверьте, что машина проверяет именно ваше утверждение.

Доверие к ядру и экосистема проверяющих
Официальное ядро Lean небольшое, но «маленький» — это ещё не аргумент безопасности. Это приглашение к переизложению. Верификация опиралась на это приглашение очень активно. Экспортированное доказательство проверяли не только ядром Lean, но и con-leche и con-ron, а также несколькими сторонними проверяющими, написанными на разных языках программирования, которые работали с одним и тем же инертным файлом экспорта. Слово инертный здесь важно: проверяющие никогда не выполняют код из исходников доказательства, так что гипотетический вредоносный фрагмент, спрятанный в семнадцати миллионах строк, не имеет среды выполнения, в которой мог бы что-то сделать. Это разница между чтением документа и запуском вложения.
Два тяжеловеса заслуживают отдельного упоминания, потому что у каждого из con-leche и con-ron есть формальное доказательство — относительно теории множеств — что они не могут принять ложное доказательство. Это закрывает обычную регрессию: да, ядро Lean теоретически может содержать ошибку корректности, поэтому проверьте другим ядром; да, и в нём может быть ошибка; но когда аргумент о корректности самого проверяющего машинно проверен относительно другого базиса, поверхность атаки сводится к «ошибке, которая одновременно переживает несколько реализаций, несколько языков и несколько фундаментальных систем». Не невозможно. Но и не то, на что стоит планировать. Я писал о том, как даже борроу-чекер Rust выпустил дыру в корректности, так что я не говорю «доверяй ядру» легкомысленно. Ответ никогда не был в одном доверенном компоненте. Это разнообразная популяция проверяющих и общий переносимый формат доказательств — N-версионное программирование, которым авиация занимается десятилетиями, наконец применённое к самой истине.
import Mathlib
-- The statement, maintained and vetted in Mathlib, that the
-- new library proves. Anybody can inspect what the words mean.
#check RiemannHypothesis
-- A trivial kernel-checked proof. The kernel reduces 2 + 2 to 4
-- and accepts rfl; no tactic code runs at check time.
theorem two_add_two : 2 + 2 = 4 := rfl
-- Ask the kernel what this proof's trust base actually is:
#print axioms two_add_two
-- reports that the proof depends on no axioms at all
-- Had someone snuck in `sorry` (Lean's escape hatch) or a custom
-- axiom, this is where it shows up: as `sorryAx` or worse, in
-- the dependency list of the final theorem.
Последний механизм — это журнал аудита, которого не хватает большинству систем. #print axioms спрашивает у ядра постфактум, на какие допущения на самом деле опирается доказательство. Любой обход в Lean — sorry, объявленная пользователем аксиома, некорректное использование unsafe — оставляет след в этом списке. Представьте, что ваша сборка может ответить на вопрос «что вы предположили?» с такой же точностью: этот сервис предполагает, что часы монотонны, этот — что TLS 1.3, этот — что очередь доставляет хотя бы один раз. У большинства наших систем есть именно такие допущения. Почти ни одна не может перечислить их по запросу.
Управление зависимостями в масштабе Mathlib
Одна строка в заявлении сообщества — чистая поэзия управления зависимостями: кодовая база зависит напрямую только от Mathlib. Никаких вендорных форков, никаких приватных веток стандартной библиотеки, никаких патчей вне дерева. Семнадцать миллионов строк исследовательской математики стоят на одном общем, постоянно интегрируемом upstream. Это работает только потому, что Mathlib функционирует скорее как орган стандартизации с CI, чем как репозиторий пакетов: строгое ревью, общий кеш, чтобы участники не пересобирали вселенную при каждом pull request, и культура, в которой вынести свои определения в upstream — норма, а не одолжение сообществу.
И именно этот порядок — сначала утверждение, потом доказательство — то, что команды разработки обычно делают наоборот. Определение гипотезы Римана было слито, проверено и укреплено в общей библиотеке до того, как пришло доказательство. Когда пришла полезная нагрузка на семнадцать миллионов строк, спорить о том, что она утверждает, уже не приходилось: утверждение уже было инфраструктурой. Сравните с тем, как большие кодовые базы обычно принимают огромный вклад: интерфейсы определяет сам вклад, ревью идёт в спешке, и к моменту, когда кто-то замечает, что контракт уплыл, три другие команды уже зависят от уплывшей версии. Дисциплина Mathlib — сначала канонизировать словарь публично, а потом строить на нём работу — ровно то, что делает здоровая платформенная команда со своими внутренними API. Разница в том, что они действительно это делают.

Где контринтуитивный тезис перестаёт работать
Теперь о пересмотре, потому что тезис заслуживает честной проверки на прочность. Независимые проверяющие не так независимы, как звучит в риторике. Они разделяют одну метатеорию, многие имеют общее происхождение дизайна, и авторы проверяющих общаются между собой; разнообразие языков программирования — это не разнообразие логики. Был и прецедент проскальзывания: поддельное опровержение гипотезы Коллатца однажды прошло через один из таких независимых проверяющих, прежде чем его поймали. Честная формулировка аргумента о доверии — та, которую сформулировал внимательный наблюдатель: чтобы доказательство было неверным, одна ошибка должна была бы одновременно затронуть внутреннюю непротиворечивость проверяющих и это конкретное доказательство во всех реализациях. Ничтожно мало. Но «ничтожно мало» — это вероятность, а в заявлении сообщества написано «полная уверенность», а это уже социология.
Есть и несущая стена, о которой не упоминают четыре опубликованных критерия. По всем отзывам, доказательство создавалось с большой помощью ИИ, а Альпёге направлял процесс: разбивал задачу, распознавал тупики, понимал, какие леммы пахнут ошибкой. Этот человеческий опыт выполняет реальную эпистемическую работу, а сертификат в том виде, в каком он написан, на него вообще не опирается, и это меня беспокоит. Я уже писал о разделении между генерацией гипотез LLM и механической проверкой доказательств, и здесь это разделение на максимальных ставках: машина предложила в беспрецедентном масштабе, машина проверила в беспрецедентном масштабе, а редкий человек сидел на стыке и делал всё понятным. Убрать этого человека из официальной истории — значит сделать историю чище и менее правдивой.
Инженерные уроки для программ, проверенных машиной
- Держите доверенную вычислительную базу крошечной и скучной. Каждая строка, которой вы обязаны доверять, — это обязательство; каждая строка, которую вы лишь проверяете, — это данные.
- Экспортируйте в инертный переносимый формат. Верификация должна работать с документом, а не с живым процессом, который может выполнить какой-нибудь сюрприз.
- Проверяйте утверждение, а не только аргумент. Постройте компаратор. Докажите, что ваш артефакт соответствует контракту, прежде чем праздновать доказательство.
- Всерьёз диверсифицируйте проверяющих. Разные языки помогают; разные основания помогают ещё больше; один проверяющий с доказательством непротиворечивости стоит двух, которые списывают друг у друга.
- Делайте сборки воспроизводимыми, а артефакты — адресуемыми по содержимому. «Десятки людей воспроизвели один и тот же файл экспорта» — это фраза, к которой должен стремиться любой релизный конвейер.
- Канонизируйте общий словарь в upstream до того, как придёт крупный вклад. Сначала определения, потом героизм.
- Перечисляйте допущения машинно. Если ваша система не может ответить на вопрос «от чего вы зависите?», вы не знаете, что выпустили.
В основе списка лежит одна идея: тесты выборочно проверяют пространство, доказательства исчерпывают его, а интересная середина — property-based тестирование, model checking, символьное выполнение — это индустрия, которая медленно и неохотно ползёт из первого лагеря ко второму. Никто не просит вас формализовать ваше CRUD-приложение. Но граница того, что «должно проверяться машиной», постоянно сдвигается: криптографические примитивы, протоколы консенсуса, смарт-контракты, бортовое ПО, верификаторы eBPF в ядре. У каждого из этих сообществ был момент «нам действительно стоит делать это по-настоящему, как в Lean», обычно сразу после дорогостоящего инцидента. Верификация гипотезы Римана показывает, что инструменты, культура и экосистема проверяющих способны выдержать вес чего-то по-настоящему огромного. Отговорки закончились.
Сто лет попыток
Как человек, занимающийся языками, я не могу не видеть в этом выплату по очень старой ставке. Гильберт включил гипотезу Римана в свой список в 1900 году. Де Брёйн начал Automath в 1967-м. Робин Милнер создал ML в 1970-х специально как метаязык для написания тактик доказательств — вся семья ML, из которой вышли OCaml и Haskell и которая дошла до системы типов Rust, восходит к инструментам машинно проверенных доказательств. Манифест QED в 1990-х спрашивал, почему вся математика ещё не формализована, и в основном получил пожатие плеч. Потом Теорема о четырёх красках попала в Coq, затем теорема Фейта–Томпсона, а Эксперимент с тензорами Лиу доказал, что современная исследовательская математика, а не только классика, способна выдержать встречу с ядром. Каждый из этих проектов кто-то назвал трюком. Каждый обучил сообщество и укрепил библиотеку, на которой стоял следующий.
Итак: прав ли мой исходный тезис? Отчасти. Математики получили теорему, и к утру уже задавали лучший вопрос — чему учит доказательство, а этого семнадцать миллионов проверенных строк автоматически не делают. Инженеры получили кое-что более редкое: чертёж, проверенный в условиях максимальной строгости, для построения артефактов, которые слишком велики для чтения любым человеком, и всё же под них сообщество ставит своё имя. В следующий раз, когда кто-то на ревью дизайна скажет, что настоящая верификация не масштабируется, вы точно будете знать, какой журнал сборки ему показать.


