Wyobraź sobie język programowania, w którym zamiast tworzyć aplikację webową, sterownik urządzenia czy skrypt administracyjny, zapisujesz twierdzenie matematyczne. Następnie opisujesz jego dowód, a kompilator sprawdza, czy każdy krok rozumowania jest logicznie poprawny.
Brzmi jak eksperyment akademicki? Być może. Ale właśnie takie narzędzie stało się jednym z najważniejszych elementów niezwykłej historii matematycznej z listopada 2026 roku.
Mowa o Lean 4 – języku programowania i asystencie dowodzenia twierdzeń, który pozwala zapisywać matematykę w postaci formalnej, a następnie weryfikować ją za pomocą niewielkiego, zaufanego jądra logicznego.
Co więcej, Lean znalazł się w centrum wydarzenia, które może zmienić sposób prowadzenia badań matematycznych. Levent Alpöge, matematyk związany z Anthropic, opublikował formalny dowód hipotezy Riemanna przygotowany we współpracy z modelem AI Claude. Dowód został zapisany w ogromnym projekcie Lean, a społeczność rozwijająca Lean i bibliotekę Mathlib potwierdziła poprawność formalnego twierdzenia i dowodu.

Nie oznacza to, że Claude po prostu wpisał kilka równań i rozwiązał problem. Za tym wydarzeniem stoją zaawansowana matematyka, ogromna baza formalnych definicji, tysiące zależności i mechanizm weryfikacji, który nie wybacza nawet drobnych błędów logicznych.
Przy okazji jest to świetny przykład technologii, którą warto poznać również jako programista, administrator Linuksa czy inżynier DevOps. Lean można zainstalować na zwykłym komputerze z Linuksem, pisać w nim kod, budować projekty i uruchamiać formalne dowody matematyczne.
1. Czym właściwie jest Lean?
Oficjalna strona projektu znajduje się pod adresem: https://lean-lang.org
Lean to jednocześnie:
- język programowania funkcyjnego;
- system typów zależnych (dependent types);
- interaktywny asystent dowodzenia twierdzeń;
- środowisko do formalizacji matematyki;
- narzędzie do maszynowej weryfikacji dowodów.
Najważniejsze jest ostatnie zastosowanie.
W tradycyjnym programowaniu piszemy kod, który ma wykonać określone zadanie. Kompilator sprawdza składnię, typy i pewne właściwości programu. Nie sprawdza jednak automatycznie, czy cała logika biznesowa aplikacji jest zgodna z naszymi intencjami.
W Lean możemy pójść znacznie dalej. Możemy zapisać twierdzenie:
Dla każdej liczby naturalnej a i b dodawanie jest przemienne.
A następnie przedstawić formalny dowód, który system zweryfikuje.
Przykładowo:
theorem add_comm_demo (a b : Nat) : a + b = b + a := by
exact Nat.add_comm a b
To niewielki fragment kodu, ale zawiera kilka istotnych elementów:
theoremdeklaruje twierdzenie;a b : Natokreśla, że argumentami są liczby naturalne;a + b = b + ajest własnością, którą chcemy udowodnić;byrozpoczyna blok dowodu;exact Nat.add_comm a bwskazuje istniejące twierdzenie, które rozwiązuje nasz problem.
Jeżeli wszystko jest poprawne, Lean zaakceptuje dowód.
Jeśli zmienimy twierdzenie na fałszywe, na przykład:
theorem wrong_demo (a b : Nat) : a + b = a - b := by
exact Nat.add_comm a b
system zgłosi błąd, ponieważ wskazany dowód nie pasuje do oczekiwanego twierdzenia.
To podstawowa różnica między zwykłym tekstem matematycznym a formalnym dowodem: nie wystarczy napisać, że coś jest prawdą. Trzeba przedstawić strukturę rozumowania, którą komputer może zweryfikować.
2. Dlaczego formalne dowody matematyczne są tak trudne?
W tradycyjnej matematyce człowiek często pomija oczywiste kroki.
Jeżeli matematyk zapisze:
[
(a+b)^2=a^2+2ab+b^2
]
nie musi za każdym razem udowadniać od podstaw, dlaczego wzór jest prawdziwy. Czytelnik zna algebrę i rozumie, że wystarczy zastosować rozdzielność mnożenia względem dodawania.
W formalnym systemie trzeba mieć jednak odpowiednie definicje, twierdzenia pomocnicze i reguły, które pozwolą uzasadnić taki krok.
W praktyce oznacza to, że nawet pozornie prosty dowód może wymagać wielu operacji.
Wyobraźmy sobie bardziej złożone twierdzenie:
[
\forall n \in \mathbb{N}, \quad n(n+1) \text{ jest parzyste}
]
Człowiek może udowodnić je w kilku zdaniach:
- Jedna z dwóch kolejnych liczb naturalnych musi być parzysta.
- Iloczyn zawierający liczbę parzystą jest parzysty.
- Zatem (n(n+1)) jest parzyste.
Lean potrzebuje formalnej reprezentacji tych pojęć i kroków.
Przykładowy dowód:
import Mathlib
theorem consecutive_product_even (n : Nat) :
Even (n * (n + 1)) := by
rcases Nat.even_or_odd n with h | h
· exact h.mul_right _
· have hnext : Even (n + 1) := by
exact Nat.even_add_one_of_odd h
exact Even.mul_left hnext
To przykład poglądowy pokazujący styl pracy z biblioteką Mathlib. Konkretne nazwy twierdzeń pomocniczych mogą zależeć od wersji biblioteki, dlatego kod należy sprawdzić w używanym projekcie.
W przypadku zaawansowanej matematyki problem jest wielokrotnie trudniejszy. Trzeba formalizować między innymi:
- analizę matematyczną;
- teorię liczb;
- algebrę abstrakcyjną;
- analizę zespoloną;
- geometrię algebraiczną;
- teorię reprezentacji;
- teorię grup;
- topologię;
- zaawansowane konstrukcje matematyczne.
Często najtrudniejszą częścią nie jest samo zapisanie ostatniego kroku dowodu, lecz przygotowanie całej infrastruktury matematycznej, która pozwoli ten krok wykonać.
Właśnie dlatego Lean jest tak interesujący: nie tylko sprawdza pojedyncze równania, ale może obsługiwać całe rozbudowane teorie matematyczne.
3. Hipoteza Riemanna – jeden z największych problemów matematyki
Żeby zrozumieć znaczenie wydarzeń z listopada 2026 roku, trzeba poznać problem, którego dotyczyły.
Hipoteza Riemanna została sformułowana przez niemieckiego matematyka Bernharda Riemanna w 1859 roku.
Dotyczy funkcji dzeta Riemanna:
[
\zeta(s)=\sum_{n=1}^{\infty}\frac{1}{n^s}
]
W uproszczeniu jest to funkcja matematyczna, której własności są bardzo mocno związane z rozmieszczeniem liczb pierwszych.
Liczby pierwsze to takie liczby naturalne większe od jedności, które mają dokładnie dwa dodatnie dzielniki: 1 i samą siebie.
Przykłady:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29...
Na pierwszy rzut oka ich rozmieszczenie wydaje się chaotyczne. Nie pojawiają się w regularnych odstępach.
Hipoteza Riemanna dotyczy zer funkcji dzeta w płaszczyźnie liczb zespolonych. W szczególności mówi, że wszystkie jej nietrywialne zera mają część rzeczywistą równą jednej drugiej:
[
\operatorname{Re}(s)=\frac{1}{2}
]
To właśnie słynna prosta krytyczna.
Dlaczego ma to znaczenie?
Ponieważ prawdziwość hipotezy pozwoliłaby znacznie lepiej opisać odchylenia w rozmieszczeniu liczb pierwszych. Ma ona ogromne znaczenie dla teorii liczb, a pośrednio dla wielu obszarów matematyki i informatyki.
Nie jest to więc zagadnienie dotyczące wyłącznie abstrakcyjnej matematyki. Teoria liczb stanowi również jeden z fundamentów współczesnej kryptografii.
Hipoteza Riemanna znajduje się na liście siedmiu problemów milenijnych Clay Mathematics Institute. Za rozwiązanie każdego z nich przewidziano nagrodę w wysokości miliona dolarów, przy spełnieniu określonych warunków regulaminowych.
Oficjalny opis problemu: https://www.claymath.org/millennium/Riemann-Hypothesis
Warto zauważyć, że hipoteza pozostawała nierozwiązana od 1859 roku. Sprawdzono ogromną liczbę jej przypadków numerycznych, ale obliczenia dla skończonej liczby zer nie zastępują dowodu dotyczącego wszystkich nietrywialnych zer.
4. Listopad 2026: AI, Lean i formalny dowód hipotezy Riemanna
20 listopada 2026 roku Levent Alpöge opublikował informację o dowodzie hipotezy Riemanna, nad którym pracował wspólnie z modelem Claude.
Nie był to zwykły dokument PDF z kilkoma stronami matematycznych wzorów.
Głównym rezultatem była ogromna biblioteka kodu Lean, która zawierała formalizację dowodu.
Skala przedsięwzięcia jest trudna do wyobrażenia:
| Element | Skala |
|---|---|
| Liczba plików Lean | około 175 000 |
| Liczba linii kodu | około 17 milionów |
| Liczba deklaracji twierdzeń i lematów | setki tysięcy |
| Wersja Lean | 4.33.1 |
| Wersja Mathlib | 4.33.1 |
To nie jest mały projekt, który można po prostu otworzyć w edytorze i przejrzeć w jeden wieczór.
Dla porównania: nawet duże projekty infrastrukturalne, systemy operacyjne i rozbudowane platformy programistyczne potrafią zawierać miliony linii kodu. Tutaj podobna skala została wykorzystana do formalnego opisu matematycznego rozumowania.
Co ciekawe, Alpöge nie przedstawił klasycznej, czytelnej dla matematyka publikacji zawierającej cały dowód krok po kroku. W opublikowanej nocie wyjaśnił, że tekstowa wersja wygenerowanego materiału była absurdalnie długa – mowa była o ponad 250 tysiącach stron.
Zamiast tego opublikował formalizację w Lean.
To zasadniczo zmienia sposób, w jaki można podejść do weryfikacji takiego rezultatu.
Źródła:
- Informacja społeczności Lean i Mathlib
- Raport weryfikacyjny Andrew Sutherlanda z MIT
- Opracowanie dotyczące formalizacji
5. Czy to naprawdę Claude udowodnił hipotezę Riemanna?
To najciekawsze pytanie i jednocześnie miejsce, w którym warto zachować precyzję.
Nie należy przedstawiać tej historii jako sytuacji, w której model językowy samodzielnie rozwiązał problem bez udziału człowieka.
Levent Alpöge jest matematykiem i uczestniczył w procesie badawczym. Według jego opisu pracował nad rozwiązaniem wspólnie z Claude. Model pomagał w rozwijaniu rozumowania i dostarczaniu technicznych elementów argumentacji matematycznej.
Można więc mówić o dowodzie opracowanym przy współudziale AI i sformalizowanym w Lean.
To ważne rozróżnienie.
Duży model językowy może generować bardzo przekonujący tekst matematyczny, ale sam tekst nie stanowi dowodu. Model może popełniać błędy, przeskakiwać nieuzasadnione kroki albo przedstawiać fałszywe twierdzenia w sposób wyglądający na wiarygodny.
Lean rozwiązuje część tego problemu.
Zamiast pytać, czy wygenerowany przez AI tekst wygląda sensownie, możemy zapytać, czy formalny obiekt dowodu przechodzi kontrolę logiczną.
W tym przypadku odpowiedź społeczności Lean i Mathlib była wyjątkowo istotna.
21 listopada opublikowano wspólne oświadczenie, w którym społeczności potwierdziły poprawność zarówno formalnego twierdzenia, jak i dowodu.
To nie była wyłącznie informacja, że kod się kompiluje. Weryfikacja obejmowała kilka niezależnych zagadnień:
- Czy formalne twierdzenie rzeczywiście odpowiada hipotezie Riemanna?
- Czy cały projekt można poprawnie zbudować?
- Czy dowód nie opiera się na dodatkowych, nieuzasadnionych założeniach?
- Czy jądro Lean akceptuje formalny dowód?
- Czy niezależne narzędzia weryfikujące również akceptują eksport dowodu?
Społeczność Lean i Mathlib stwierdziła, że te kryteria zostały spełnione.
Źródło: Lean verification of the Riemann Hypothesis.
Czy hipoteza Riemanna jest już oficjalnie rozwiązana?
Trzeba rozróżnić dwie rzeczy.
Formalna poprawność dowodu: społeczność Lean i Mathlib potwierdziła poprawność formalnego dowodu.
Pełne zrozumienie matematyczne: nadal pozostaje zadaniem dla matematyków. Sam fakt, że komputer zweryfikował dowód, nie oznacza, że środowisko matematyczne już w pełni zrozumiało wszystkie nowe idee, które do niego doprowadziły.
Clay Mathematics Institute nadal prezentuje hipotezę Riemanna na swojej stronie jako problem nierozwiązany. Formalne potwierdzenie nie jest automatycznie tym samym co zakończenie wszystkich procedur związanych z nagrodą milenijną i powszechną akceptacją matematyczną.
To istotny szczegół, którego nie warto pomijać w medialnych nagłówkach.
6. Jak Lean może zweryfikować dowód? Poznajmy jego jądro
Jednym z najważniejszych elementów Lean jest tak zwany kernel, czyli niewielki mechanizm sprawdzający poprawność dowodów.
W dużym uproszczeniu wygląda to tak:
Matematyczne twierdzenie
|
v
Formalizacja w Lean
|
v
Taktyki i konstrukcja dowodu
|
v
Obiekt dowodu (proof term)
|
v
Lean Kernel
|
+---------+---------+
| |
v v
ACCEPT REJECT
Dowód poprawny Błąd logiczny
Programista może korzystać z rozbudowanych taktyk, automatyzacji i bibliotek. Nie musi ręcznie zapisywać każdego elementarnego kroku w najniższej możliwej postaci.
Jednak ostatecznie wynik musi zostać zaakceptowany przez jądro.
To trochę przypomina sytuację, w której duży system CI/CD wykonuje setki skomplikowanych etapów budowania aplikacji, ale końcowy artefakt musi przejść niezależną kontrolę.
W Lean można korzystać z taktyk automatyzujących rozumowanie:
by
omega
by
simp
by
norm_num
Ich działanie jest różne:
omegaautomatyzuje wiele problemów arytmetycznych dotyczących liczb całkowitych i naturalnych;simpupraszcza wyrażenia, wykorzystując znane reguły;norm_numpomaga rozwiązywać konkretne problemy arytmetyczne.
Nie oznacza to jednak, że Lean bez ograniczeń potrafi rozwiązać dowolny problem matematyczny. Taktyki działają w określonych obszarach i korzystają z dostępnej wiedzy formalnej.
Właśnie dlatego biblioteka Mathlib jest tak ważna.
7. Mathlib – ogromna biblioteka matematyczna dla Lean
W świecie Linuksa programista przyzwyczajony jest do bibliotek, pakietów i zależności.
Nie piszemy od zera obsługi HTTP, parsera JSON czy funkcji kryptograficznych. Korzystamy z istniejących bibliotek.
Podobnie działa Mathlib.
Mathlib to rozbudowana, otwarta biblioteka matematyczna dla Lean, zawierająca definicje, twierdzenia, lematy i narzędzia automatyzujące dowody.
Można w niej znaleźć formalizacje wielu obszarów matematyki:
- algebry;
- teorii liczb;
- analizy rzeczywistej i zespolonej;
- geometrii;
- topologii;
- teorii miary;
- teorii kategorii;
- rachunku prawdopodobieństwa.
To bardzo istotne, ponieważ formalizacja dużego dowodu nie oznacza budowania całej matematyki od zera.
Autor może korzystać z istniejących definicji i twierdzeń, a następnie budować na nich kolejne elementy rozumowania.
Podobnie jak aplikacja w Pythonie może korzystać z NumPy, a projekt C++ z Boost, projekt Lean może korzystać z Mathlib.
Repozytorium: https://github.com/leanprover-community/mathlib4
8. Instalacja Lean na Linuksie
Przejdźmy do praktyki.
Lean można uruchomić na zwykłym komputerze z Linuksem. Nie potrzebujemy specjalnego systemu operacyjnego ani komputera z GPU.
Oficjalna dokumentacja zaleca instalację Lean przez elan, czyli menedżer wersji i toolchainów Lean.
To bardzo dobre rozwiązanie, ponieważ różne projekty mogą wymagać różnych wersji kompilatora.
Krok 1. Instalacja zależności
Na Ubuntu i Debianie:
sudo apt update
sudo apt install -y curl git
W innych dystrybucjach należy użyć odpowiedniego menedżera pakietów.
Krok 2. Instalacja elan
Uruchamiamy oficjalny instalator:
curl https://elan.lean-lang.org/elan-init.sh -sSf | sh
Instalator zaproponuje domyślną konfigurację.
Po zakończeniu instalacji dodajemy narzędzia do bieżącego środowiska:
source "$HOME/.elan/env"
Możemy również otworzyć nową sesję terminala.
Sprawdźmy instalację:
elan --version
Następnie:
lean --version
I:
lake --version
elan zarządza wersjami Lean, lean jest właściwym narzędziem języka, a lake odpowiada za projekty, zależności i budowanie.
Przykładowo:
elan 4.x.x
Lean (version 4.x.x, ...)
Lake version 5.x.x
To jedynie przykładowy format wyniku. Konkretne wersje będą zależeć od aktualnego toolchainu.
Oficjalna dokumentacja instalacji: https://lean-lang.org/install/manual
Krok 3. Instalacja edytora
Najwygodniejszym środowiskiem dla początkującego jest Visual Studio Code wraz z oficjalnym rozszerzeniem Lean 4.
Instalacja rozszerzenia:
code --install-extension leanprover.lean4
Rozszerzenie zapewnia:
- kolorowanie składni;
- podpowiedzi;
- informacje o typach;
- podgląd celów dowodzenia;
- komunikaty o błędach;
- interaktywną pracę z dowodem.
To szczególnie przydatne, ponieważ Lean jest językiem, w którym bardzo często pracujemy iteracyjnie.
Wpisujemy fragment dowodu, sprawdzamy stan, poprawiamy go i obserwujemy, jak zmienia się wynik.
Nie trzeba jednak używać VS Code. Można pracować w terminalu, a także korzystać z innych edytorów, takich jak Neovim z odpowiednim rozszerzeniem.
9. Pierwszy projekt Lean na Linuksie
Po zainstalowaniu narzędzi możemy stworzyć pierwszy projekt.
mkdir -p ~/lean-projects
cd ~/lean-projects
Tworzymy projekt korzystający z Mathlib:
lake new hello-lean math
Przechodzimy do katalogu:
cd hello-lean
Pobieramy i przygotowujemy cache Mathlib:
lake exe cache get
Następnie budujemy projekt:
lake build
Pierwsze budowanie może potrwać dłużej, ponieważ trzeba przygotować zależności i biblioteki.
Warto zauważyć podobieństwo do klasycznego projektu programistycznego:
hello-lean/
├── Main.lean
├── lakefile.toml
├── lean-toolchain
└── .lake/
Najważniejsze elementy:
Main.lean– nasz kod Lean;lakefile.toml– konfiguracja projektu i zależności;lean-toolchain– wskazanie wersji Lean;.lake/– katalog wykorzystywany przez Lake do przechowywania zależności i artefaktów.
To bardzo przypomina znane środowiska budowania projektów programistycznych.
Pierwszy dowód
Otwórzmy plik:
nano Main.lean
Wstawmy:
import Mathlib
theorem hello_lean : 2 + 2 = 4 := by
norm_num
#check hello_lean
#print hello_lean
Zapisujemy plik i sprawdzamy go:
lake env lean Main.lean
Jeśli wszystko jest poprawne, Lean zaakceptuje twierdzenie i wyświetli informacje o jego typie oraz definicji.
Właśnie wykonaliśmy pierwszy formalny dowód matematyczny.
Możemy teraz zmienić:
theorem hello_lean : 2 + 2 = 4 := by
norm_num
na:
theorem hello_lean : 2 + 2 = 5 := by
norm_num
Lean odrzuci taki dowód.
Nie dlatego, że nie podoba mu się wynik. Po prostu twierdzenie jest fałszywe.
10. Lean to nie Python – czy ma interpreter i kompilator?
To ważna kwestia dla osób, które chcą uruchamiać Lean na serwerach.
Lean nie jest typowym językiem skryptowym, w którym uruchamiamy plik i oczekujemy, że interpreter wykona kolejne instrukcje.
Jest to język kompilowany, wyposażony w mechanizm interaktywnego sprawdzania dowodów.
Najważniejsze narzędzia:
| Narzędzie | Zastosowanie |
|---|---|
lean | Sprawdzanie plików Lean i kompilacja modułów |
lake | Zarządzanie projektami i budowanie |
elan | Zarządzanie wersjami Lean |
lean --run | Uruchamianie kodu wykonywalnego z pliku Lean |
lake build | Budowanie projektu i jego zależności |
Możemy uruchomić prosty plik:
lean --run Main.lean
Jeśli zawiera kod wykonywalny, Lean może go uruchomić.
Przykład:
def greet (name : String) : String :=
"Hello, " ++ name ++ "!"
def main : IO Unit := do
IO.println (greet "Linux")
Uruchomienie:
lean --run Main.lean
Wynik:
Hello, Linux!
Możemy również budować projekt:
lake build
W przypadku większych projektów Lean i Mathlib to właśnie Lake jest podstawowym narzędziem do zarządzania procesem budowania.
11. Jak wygląda dowodzenie twierdzeń w praktyce?
Przejdźmy do nieco ciekawszego przykładu.
Chcemy udowodnić, że suma dwóch liczb parzystych jest parzysta.
Matematycznie:
[
a=2k
]
[
b=2m
]
Zatem:
[
a+b=2k+2m=2(k+m)
]
Czyli suma jest podzielna przez dwa.
W Lean możemy zapisać:
import Mathlib
theorem even_add_even
(a b : Nat)
(ha : Even a)
(hb : Even b) :
Even (a + b) := by
exact ha.add hb
Co się tutaj wydarzyło?
aibto liczby naturalne;hajest dowodem, żeajest parzyste;hbjest dowodem, żebjest parzyste;- naszym celem jest wykazanie, że ich suma również jest parzysta;
ha.add hbwykorzystuje istniejące twierdzenie dotyczące sumy liczb parzystych.
To pokazuje bardzo ważną właściwość Lean: dowody można budować warstwowo.
Nie trzeba za każdym razem rozpoczynać rozumowania od zera. Możemy korzystać z już udowodnionych twierdzeń i budować coraz bardziej zaawansowane konstrukcje.
To dokładnie tak, jak w programowaniu wykorzystujemy funkcje, biblioteki i gotowe moduły.
12. Jak bardzo skomplikowany był dowód hipotezy Riemanna?
Tutaj dochodzimy do części, która robi największe wrażenie.
Projekt opublikowany przez Alpöge zawierał około 17 milionów linii kodu Lean.
Nie należy jednak wyobrażać sobie, że każda linia odpowiada jednemu prostemu krokowi matematycznemu. W formalizacji znajdują się definicje, twierdzenia pomocnicze, konstrukcje, zależności i rozbudowane elementy infrastruktury matematycznej.
Ważne jest również to, że ogromna część wiedzy matematycznej pochodzi z Mathlib.
Weryfikacja nie polegała na przeczytaniu 17 milionów linii przez jednego człowieka.
Zamiast tego wykorzystano automatyczne narzędzia, niezależne kontrole i budowanie projektu.
Raport Andrew Sutherlanda z MIT opisuje między innymi:
- kompilację wszystkich modułów;
- sprawdzenie zależności aksjomatycznych;
- weryfikację typów głównych twierdzeń;
- kontrolę zgodności formalnego twierdzenia z definicją Mathlib;
- sprawdzanie eksportu dowodu przez niezależne narzędzia.
W opublikowanym raporcie odnotowano między innymi kompilację 175 187 modułów i wykorzystanie środowiska z 128 procesorami logicznymi oraz 244 GB pamięci RAM. Samo budowanie trwało prawie siedem godzin.
To dobrze pokazuje, że formalizacja takiego problemu nie jest zwykłym zadaniem programistycznym.
Jest to ogromny projekt matematyczno-informatyczny, wymagający zarówno wiedzy teoretycznej, jak i infrastruktury obliczeniowej.
Raport: https://math.mit.edu/~drew/grh
Czy 17 milionów linii oznacza, że dowód jest poprawny?
Sama liczba linii nie ma znaczenia dla poprawności.
Można napisać 100 milionów linii kodu, które niczego nie udowadniają.
Istotne jest to, czy końcowy obiekt dowodu rzeczywiście odpowiada właściwemu twierdzeniu i czy jest akceptowany przez zaufany mechanizm weryfikacji.
Dlatego w tej historii tak ważne były niezależne kontrole, a nie sam rozmiar archiwum.
13. Aksjomaty – czy Lean może udowodnić coś na podstawie fałszywych założeń?
To jeden z najciekawszych tematów związanych z formalnymi dowodami.
W matematyce formalnej korzystamy z aksjomatów, czyli przyjętych założeń, na których budujemy dalsze rozumowanie.
Lean ma własny system logiczny i standardowe aksjomaty.
Wśród nich znajdują się między innymi:
propext;Classical.choice;Quot.sound.
W raporcie dotyczącym dowodu hipotezy Riemanna wskazano, że główne twierdzenia korzystały wyłącznie z tych standardowych aksjomatów Lean.
Dlaczego to ważne?
Ponieważ formalny dowód może być poprawny względem określonego systemu założeń, ale jeśli dodamy nieuzasadniony aksjomat:
axiom my_assumption : False
to możemy zbudować system, w którym da się wyprowadzić dowolne twierdzenie.
Dlatego kontrola aksjomatów jest tak ważna.
W Lean możemy sprawdzić zależności konkretnego twierdzenia:
#print axioms hello_lean
W przypadku bardziej zaawansowanych projektów taka kontrola pomaga upewnić się, że dowód nie korzysta z dodatkowych, nieoczekiwanych założeń.
Warto też podkreślić, że Classical.choice nie jest automatycznie błędem ani podejrzanym dodatkiem. Jest standardowym elementem klasycznego rozumowania matematycznego.
14. Co Lean oznacza dla programistów i administratorów DevOps?
Można zapytać: po co administratorowi Linuksa wiedza o formalnych dowodach matematycznych?
Przecież nie każdy serwer potrzebuje dowodzić twierdzeń z teorii liczb.
Jednak Lean pokazuje bardzo ciekawy kierunek rozwoju inżynierii oprogramowania.
W klasycznym podejściu piszemy program, testujemy go, analizujemy logi i staramy się znaleźć błędy.
W podejściu formalnym możemy dodatkowo opisać właściwości, które program musi spełniać, i udowodnić ich poprawność.
To ma znaczenie w obszarach takich jak:
- systemy kryptograficzne;
- protokoły bezpieczeństwa;
- systemy operacyjne;
- kompilatory;
- systemy rozproszone;
- oprogramowanie medyczne;
- infrastruktura krytyczna;
- algorytmy finansowe.
Nie oznacza to, że każdy projekt powinien być formalizowany w Lean. Koszt formalizacji może być bardzo wysoki.
Ale w przypadku oprogramowania, w którym błąd może kosztować życie, miliony dolarów albo bezpieczeństwo infrastruktury, formalne metody weryfikacji mają ogromną wartość.
Przykład: weryfikacja własności algorytmu
Wyobraźmy sobie algorytm odpowiedzialny za przydzielanie zasobów w systemie produkcyjnym.
Możemy chcieć udowodnić, że:
- algorytm nie przydzieli zasobu dwóm procesom jednocześnie;
- kolejka nie traci elementów;
- określony warunek bezpieczeństwa jest zawsze zachowany;
- operacja nie zmienia stanu systemu w nieprzewidziany sposób.
Zamiast polegać wyłącznie na testach, możemy formalnie opisać wymagane własności.
To zupełnie inny poziom pewności niż zwykłe testowanie.
Testy pokazują, że program działa poprawnie dla sprawdzonych przypadków. Formalny dowód może wykazać, że określona własność zachodzi dla wszystkich przypadków objętych formalnym modelem.
Oczywiście pozostaje kwestia tego, czy model wiernie opisuje rzeczywisty system. Formalna poprawność modelu nie gwarantuje automatycznie poprawności całej infrastruktury.
15. Lean i sztuczna inteligencja – dlaczego to połączenie jest tak interesujące?
Modele językowe potrafią generować kod, analizować dokumentację, tworzyć testy i pomagać w rozwiązywaniu problemów programistycznych.
Jednak w matematyce istnieje szczególny problem: odpowiedź może wyglądać na poprawną, mimo że zawiera subtelny błąd logiczny.
Formalny system dowodzenia daje AI coś, czego nie zapewnia zwykła rozmowa z chatbotem.
Daje obiektywną informację zwrotną.
Model może zaproponować:
theorem example_theorem : 2 + 2 = 4 := by
norm_num
Lean sprawdzi, czy kod jest poprawny.
Jeżeli model popełni błąd, otrzyma komunikat i może spróbować ponownie.
Powstaje więc interesująca pętla:
Model językowy AI
|
v
Propozycja dowodu
|
v
Lean
|
+-------+-------+
| |
v v
ACCEPT ERROR
| |
v v
Dowód przyjęty Poprawa dowodu
|
+-----> AI
W przypadku hipotezy Riemanna to podejście osiągnęło niezwykłą skalę.
AI mogła pomagać w tworzeniu bardzo rozbudowanych konstrukcji, ale ostateczne sprawdzenie nie polegało na tym, że inny model językowy uznał tekst za wiarygodny.
Dowód został poddany formalnej kontroli.
To ważna różnica pomiędzy generowaniem odpowiedzi przez AI a wykorzystaniem AI do tworzenia artefaktów, które można niezależnie zweryfikować.
16. Czy można używać Lean na serwerze Linux?
Oczywiście.
Lean nie jest ograniczony do desktopowego środowiska programistycznego.
Możemy budować projekty z poziomu terminala, uruchamiać kompilację w pipeline CI/CD i przechowywać formalne dowody w repozytorium Git.
Przykładowy pipeline może wyglądać następująco:
Developer
|
v
Git repository
|
v
CI/CD runner
|
v
Install elan / select toolchain
|
v
lake update
|
v
lake exe cache get
|
v
lake build
|
v
Build successful / failed
Przykładowy skrypt kontrolny:
#!/usr/bin/env bash
set -euo pipefail
echo "[INFO] Checking Lean version"
lean --version
echo "[INFO] Checking Lake version"
lake --version
echo "[INFO] Downloading Mathlib cache"
lake exe cache get
echo "[INFO] Building project"
lake build
echo "[OK] Lean project verified"
Zapisujemy go jako:
verify.sh
Nadajemy uprawnienia:
chmod +x verify.sh
Uruchamiamy:
./verify.sh
Ważne: lake exe cache get jest potrzebne w projektach korzystających z odpowiednio skonfigurowanego cache Mathlib. Nie jest uniwersalnym poleceniem wymaganym przez każdy projekt Lean.
W środowisku CI warto przypiąć konkretną wersję toolchainu i zależności. Dzięki temu różne maszyny budują projekt w porównywalnym środowisku.
Dla administratora DevOps jest to bardzo podobne do zarządzania zależnościami w innych ekosystemach.
17. Czy formalne dowody mogą zmienić przyszłość programowania?
Prawdopodobnie tak, chociaż nie oznacza to, że za kilka lat każdy programista będzie pisał aplikacje w Lean.
Największą zmianą może być przesunięcie części pracy z testowania i wykrywania błędów na formalne opisywanie właściwości systemów.
Wyobraźmy sobie przyszłość, w której AI:
- analizuje wymagania;
- proponuje architekturę;
- generuje implementację;
- tworzy formalną specyfikację;
- przygotowuje dowody wybranych własności;
- uruchamia niezależny mechanizm weryfikacji;
- dostarcza wynik wraz z dowodami poprawności.
To nie zastąpi testów, code review, audytów bezpieczeństwa ani analizy operacyjnej.
Może jednak znacząco zwiększyć poziom zaufania do wybranych fragmentów oprogramowania.
Lean pokazuje, że połączenie AI z formalną weryfikacją jest czymś więcej niż kolejnym generatorem kodu.
To potencjalnie nowy sposób tworzenia i sprawdzania wiedzy.
Podsumowanie
Lean to znacznie więcej niż niszowy język programowania dla matematyków.
To narzędzie, które łączy programowanie funkcyjne, logikę matematyczną, system typów zależnych i automatyczną weryfikację dowodów.
Historia formalnego dowodu hipotezy Riemanna z listopada 2026 roku pokazała, jak ogromny potencjał może mieć połączenie modeli językowych z systemami formalnego dowodzenia.
Nie chodzi o to, że AI zastąpiła matematyków. Chodzi o to, że model językowy może uczestniczyć w tworzeniu bardzo złożonego rozumowania, a Lean pozwala sprawdzić jego formalną poprawność.
Dla programistów jest to fascynujący przykład tego, jak daleko można rozwinąć ideę systemu typów i kompilatora.
Dla administratorów Linuksa – kolejny dowód na to, że Linux jest środowiskiem, w którym można uruchamiać nie tylko serwery, kontenery i narzędzia DevOps, ale również zaawansowane środowiska badań matematycznych.
A dla wszystkich zainteresowanych sztuczną inteligencją to ważna lekcja: AI może zaproponować rozwiązanie, ale dopiero niezależna weryfikacja daje nam powód, by mu zaufać.
Jeśli chcesz spróbować samodzielnie, zainstaluj Lean na Linuksie, utwórz projekt z Mathlib i udowodnij pierwsze proste twierdzenie. Być może okaże się, że matematyka formalna jest znacznie bliższa programowaniu, niż początkowo się wydaje.
Źródła i materiały
- Oficjalna strona Lean
- Lean – instalacja i konfiguracja
- Lean – dokumentacja oficjalna
- Mathlib – biblioteka matematyczna dla Lean
- Lean verification of the Riemann Hypothesis – wspólne oświadczenie społeczności Lean i Mathlib
- Andrew Sutherland (MIT) – materiały dotyczące weryfikacji dowodu
- Clay Mathematics Institute – Riemann Hypothesis
- Associated Press – relacja o dowodzie opracowanym z pomocą Claude