भविष्य को आकार देने वाली तकनीक पर गहन लेख।

Lean में Riemann का सत्यापन: इंजीनियरों के लिए सबक

17 मिलियन लाइन के Lean proof ने Riemann Hypothesis को कई स्वतंत्र checkers से सत्यापित किया। प्रूफ़ असिस्टेंट इंजीनियरों को क्या सिखाते हैं, जानिए।

एक कैथेड्रल, जो आपस में जुड़े चमकते ज्यामितीय ब्लॉकों से बना है और एक विशाल मशीन-जाँचे गए proof की याद दिलाता है।
इतना बड़ा proof जिसे पढ़ा न जा सके, फिर भी उसे एक संरचना की तरह जाँचा जा सकता है, बस पूरी दीवार नहीं, उसके जोड़ों की जाँच करें।

आज की सबसे दुस्साहसी सॉफ़्टवेयर इंजीनियरिंग उपलब्धि कोई फ़्रेमवर्क, डेटाबेस या AI एजेंट नहीं, बल्कि एक proof है। Levent Alpöge ने Riemann Hypothesis का Lean सत्यापन लगभग सत्रह मिलियन लाइन की लाइब्रेरी के रूप में जारी किया, और लगभग एक दिन के भीतर वॉलंटियरों के एक वितरित समूह ने उसे कम्पाइल किया, उसके अंतिम theorem को Mathlib में मौजूद मानक statement से मिलाया, और एक्सपोर्ट किए गए proof को कई स्वतंत्र kernels से दोबारा जाँचा। इनमें से दो kernels के पास मशीन-सत्यापित तर्क हैं कि वे झूठा proof स्वीकार नहीं कर सकते।

मेरा विरोधी-मत यह है, और पहले मैं इसका बचाव करूँगा, फिर इसके कुछ हिस्से वापस लूँगा: यह इस दशक की प्रोग्रामिंग भाषाओं की सबसे महत्वपूर्ण घटना है, और इसका संख्या सिद्धांत से लगभग कोई लेना-देना नहीं है। Riemann Hypothesis तो लगभग मुद्दे से हटकर है। असली बात यह है कि अब हमारे पास शोध-स्तर के पैमाने पर एक व्यावहारिक उदाहरण है, उस समस्या का जिसके चारों ओर सॉफ़्टवेयर इंजीनियर लगातार चक्कर काटते रहते हैं पर कभी उस पर पूरी तरह उतरते नहीं: ऐसा artifact कैसे बनाया जाए जिसे कोई इंसान पूरा पढ़ ही न सके, फिर भी उसकी जाँच इतनी कड़ी हो कि अजनबी लोग उस पर अपनी पेशेवर साख दाँव पर लगाने को तैयार हों?

सत्रह मिलियन लाइन के Lean सत्यापन का असली मतलब

Lean की नींव उस विचार पर टिकी है जो Nicolaas de Bruijn ने 1960 के दशक के अंत में Automath पर काम करते हुए विकसित किया था। Automath गणित को मशीन-जाँच योग्य रूप में लिखने की शुरुआती प्रणालियों में से एक था। इस विचार को अब de Bruijn criterion कहा जाता है: एक proof assistant को ऐसे proof objects बनाने चाहिए जिन्हें एक छोटा, स्वतंत्र checking program अकेले सत्यापित कर सके। सिस्टम का बड़ा और चतुर हिस्सा, यानी elaborator, tactic engine, और वह automation जो मानव-शैली के proof scripts को formal objects में बदलता है, स्पष्ट रूप से भरोसेमंद नहीं है। वह एक कम्पाइलर है, और किसी भी कम्पाइलर की तरह उसमें बग हो सकते हैं। भरोसा kernel में रहता है, एक छोटे प्रोग्राम में जो पूरी तरह elaborate किए गए proof terms को logic के नियमों के अनुसार type-check करता है।

यही आर्किटेक्चर सत्रह मिलियन लाइन के artifact को सार्थक बनाता है। वह proof किसी ने पढ़ा नहीं। पढ़ा जा ही नहीं सकता था। यह किसी बड़े operating system के घटक जितना बड़ा है, और ज़्यादातर मशीन-जनित और मशीन-आकार का है। पर सत्यापन प्रक्रिया इसे उसी तरह देखती है जैसे एक अच्छा build system compiled binary को देखता है: दर्जनों लोगों ने लाइब्रेरी को स्वतंत्र रूप से कम्पाइल किया और बिल्कुल वही raw proof export file, बाइट-दर-बाइट, दोबारा बनाई। यह एक hermetic, deterministic build है जो content-addressable artifact बनाता है, और असली दिलचस्प हिस्सा यहीं से शुरू होता है, क्योंकि checkers जो इस्तेमाल करते हैं वह artifact है, सोर्स नहीं।

जो proof आप पढ़ नहीं सकते, वह फिर भी भरोसे लायक हो सकता है। सामान्य code review का यही उलट पूरी कहानी का सार है।

सॉफ़्टवेयर से जुड़े लोगों को इस उलटफेर पर थोड़ा रुककर सोचना चाहिए। हमारी आम गुणवत्ता-गारंटी यह है कि कोई इंसान diff खोलकर उसे घूरता है। यह तरीका प्रति रिव्यूअर प्रति सप्ताह शायद कुछ हज़ार लाइनों तक चलता है, उसके बाद घूरना सिर्फ़ दिखावा बन जाता है। Lean समुदाय का जवाब है कि भरोसे को स्टैक में नीचे ले जाओ: एक छोटे kernel पर भरोसा करो, उस kernel के स्वतंत्र री-इम्प्लीमेंटेशनों की विविधता पर भरोसा करो, और उसके ऊपर का सब कुछ, चाहे वह कितने भी मिलियन लाइन का हो, गद्य नहीं बल्कि जाँचे जाने वाला डेटा समझो। यह गणित की कोई चालाकी नहीं है। यह एक इंजीनियरिंग रुख है।

स्टेटमेंट समस्या: सही theorem को सिद्ध करना

समुदाय ने जो पहली चीज़ जाँची, वह proof नहीं था, बल्कि statement था। बाहर के लोग इस हिस्से को लगातार कम आँकते हैं, और formalization परियोजनाएँ अक्सर यहीं चुपचाप दम तोड़ देती हैं। Proof assistant आपको पूरी कठोरता से गलत चीज़ सिद्ध करने देगा, क्योंकि logic को इससे कोई मतलब नहीं कि आपका इरादा क्या था। इसका क्लासिक उदाहरण एक सत्यापित sorting routine है जिसकी specification कहती है कि output क्रमबद्ध होगा, पर यह कहना भूल जाती है कि वह input का permutation भी है। खाली list बड़े मज़े से sorted है। Proof पास हो जाता है। फ़ंक्शन बेकार है।

तो इस काम का प्रमाणपत्र एक ऐसे तथ्य पर टिका है जिसे पढ़ते हुए आसानी से नज़रअंदाज़ हो जाता है: statement RiemannHypothesis पहले से Mathlib में मौजूद था, जहाँ उसकी जाँच वे लोग कर चुके थे जो analytic number theory और Lean की encoding परंपराएँ, दोनों जानते हैं: zeros कहाँ हो सकते हैं, trivial zeros को कैसे बाहर रखा जाता है, और function असल में किस पर परिभाषित है। इसके बाद समुदाय ने एक फ़ाइल जोड़ी जो ठीक उसी statement को अलग करती है, जिसमें केवल Mathlib इम्पोर्ट होता है, और दो स्वतंत्र टूल (comparator और con-leche --compare) से पुष्टि की कि Alpöge की लाइब्रेरी जो theorem सिद्ध करती है वह ठीक वही statement है। कोई नज़दीकी चूक नहीं, कोई मिलता-जुलता शब्दचित्र नहीं जिसमें चुपचाप कोई कमज़ोर hypothesis हटा दी गई हो। मैं पहले भी कह चुका हूँ कि specification और implementation के बीच का फ़ासला ही बग्स का घर है, और formal गणित वह जगह है जहाँ यह सच सिर्फ़ ब्लॉग पोस्ट न रहकर समर्पित टूलिंग वाली checklist का आइटम बन जाता है।

ध्यान दीजिए कि उद्योग के मानकों के हिसाब से यह अनुशासन कितना असामान्य है। आपने आखिरी बार कब किसी टीम को ऐसा टूल बनाते देखा जिसका इकलौता काम यह साबित करना हो कि उनका सिस्टम जो करता है वही वह है जो contract कहता है? हम contract के कुछ नमूनों पर tests लिखते हैं। हम type signatures लिखते हैं जो उसकी तरफ़ इशारा करते हैं। Lean समुदाय ने ऐसे comparators बनाए जो उसे पहचानते हैं। अगर इस पूरे मामले से आप एक ही बात घर ले जाएँ, तो यही लें: यह जश्न मनाने से पहले कि मशीन ने आपका proof जाँच लिया, यह जाँचें कि मशीन सचमुच आपका दावा जाँच रही है।

दो लगभग एक जैसी पीतल की चाबियाँ एक आवर्धक शीशे के नीचे, एक कीहोल में फिट होती हुई और दूसरी सूक्ष्म रूप से बेमेल।
लगभग-सही statement का proof उस चाबी जैसा है जिसका एक दाँत अलग है: प्रभावशाली, और बेकार।

Kernel पर भरोसा और checker पारिस्थितिकी तंत्र

Lean का आधिकारिक kernel छोटा है, पर 'छोटा' अपने आप में सुरक्षा का तर्क नहीं है। यह दोबारा इम्प्लीमेंट करने का निमंत्रण है, और सत्यापन ने इस निमंत्रण को पूरी ताकत से स्वीकार किया। एक्सपोर्ट किया गया proof सिर्फ़ Lean के kernel से नहीं, बल्कि con-leche और con-ron से, और अलग-अलग प्रोग्रामिंग भाषाओं में लिखे कई third-party checkers से भी जाँचा गया, जो सभी एक ही निष्क्रिय export file को पढ़ रहे थे। शब्द निष्क्रिय मायने रखता है: checkers proof के सोर्स से कोई कोड कभी execute नहीं करते, इसलिए सत्रह मिलियन लाइनों में छिपे किसी संभावित दुर्भावनापूर्ण snippet के पास काम करने के लिए कोई runtime ही नहीं है। यह किसी दस्तावेज़ को पढ़ने और किसी attachment को चलाने के फ़र्क जैसा है।

दो भारी-भरकम checkers का ज़िक्र विशेष रूप से ज़रूरी है, क्योंकि con-leche और con-ron दोनों के साथ set theory के सापेक्ष एक औपचारिक proof आता है कि वे झूठा proof स्वीकार नहीं कर सकते। इससे वह आम चक्र टूटता है: हाँ, Lean के kernel में सैद्धांतिक रूप से soundness bug हो सकता है, इसलिए दूसरे kernel से जाँचो; हाँ, उस दूसरे में भी हो सकता है; लेकिन जब checker का correctness तर्क खुद किसी अलग foundation के विरुद्ध मशीन-सत्यापित हो, तो हमला-सतह सिमटकर बस इतनी रह जाती है: 'एक ऐसा बग जो एक साथ कई implementations, कई भाषाओं और कई foundational systems में बचा रहे'। असंभव नहीं, पर ऐसी चीज़ नहीं जिसके लिए योजना बनाई जाए। मैंने लिखा है कि Rust के borrow checker में भी soundness की खामी आ गई थी, इसलिए मैं 'kernel पर भरोसा करो' जैसी बात हल्के में नहीं कहता। जवाब कभी एक भरोसेमंद घटक नहीं था। यह checkers की विविध आबादी और एक साझा, पोर्टेबल proof format है: N-version programming, जिसे एविऑनिक्स दशकों से अपनाता आया है, अब आखिरकार सच्चाई पर भी लागू हुई है।

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.

यह आखिरी तंत्र वह audit trail है जो ज़्यादातर सिस्टमों में नहीं होता। #print axioms kernel से बाद में पूछता है कि proof असल में किन धारणाओं पर टिका है। Lean में हर चालाकी, जैसे sorry, उपयोगकर्ता द्वारा घोषित axiom, या गलत इस्तेमाल हुआ unsafe, उस सूची में अपना निशान छोड़ता है। सोचिए कि आपका build भी 'तुमने क्या मान लिया था?' का उतनी ही सटीकता से जवाब दे सके: यह सेवा मानती है कि घड़ी monotonic है, वह TLS 1.3 मानती है, यह queue कम से कम एक बार डिलीवरी की गारंटी देती है। हमारे ज़्यादातर सिस्टम में ठीक ऐसी धारणाएँ होती हैं। पर उनमें से शायद ही कोई माँगने पर उन्हें गिनकर बता सके।

Mathlib-स्तर पर dependency management

समुदाय के statement की एक पंक्ति शुद्ध dependency-management की कविता है: codebase सीधे केवल Mathlib पर निर्भर है। कोई vendored fork नहीं, standard library की कोई निजी शाखा नहीं, कोई ऐसा patch नहीं जो tree से बाहर रखा गया हो। सत्रह मिलियन लाइन का शोध-गणित एक ही साझा, लगातार integrate होने वाले upstream पर टिका है। यह इसलिए संभव है क्योंकि Mathlib एक package repository से ज़्यादा standards body की तरह काम करता है, जिसमें सख़्त review होता है, साझा cache होता है ताकि हर pull पर योगदानकर्ताओं को पूरी दुनिया दोबारा न बनानी पड़े, और ऐसी संस्कृति है जिसमें अपनी definitions upstream भेजना एहसान नहीं बल्कि डिफ़ॉल्ट है।

और यही क्रम, पहले statement फिर proof, वह हिस्सा है जिसे इंजीनियरिंग टीमें उल्टा कर देती हैं। Riemann Hypothesis की definition proof आने से पहले साझा लाइब्रेरी में merge, review और मज़बूत की जा चुकी थी। जब सत्रह मिलियन लाइन वाला payload आया, तो इस पर कोई बहस नहीं थी कि वह क्या दावा करता है; दावा पहले से infrastructure बन चुका था। तुलना कीजिए कि ज़्यादातर बड़े codebases बड़े योगदान को कैसे निगलते हैं: interfaces उसी योगदान द्वारा तय होते हैं, review दबाव में होता है, और जब तक किसी को पता चलता है कि contract खिसक गया है, तब तक तीन और टीमें उसी खिसके हुए संस्करण पर निर्भर हो चुकी होती हैं। Mathlib का अनुशासन, यानी पहले सार्वजनिक रूप से शब्दावली को मानक बनाना और फिर उस पर काम होने देना, वही है जो एक स्वस्थ platform team अपने आंतरिक APIs के साथ करती है। फ़र्क बस इतना है कि वे सचमुच करते हैं।

एक विशाल स्वचालित गोदाम में रोबोटिक भुजाएँ एक जैसे मोम-सील वाले crates को कन्वेयर बेल्ट पर आगे बढ़ा रही हैं।
एक साझा upstream, और हर उपभोक्ता उसी एक जैसे artifact को दोबारा बनाता है: dependency management एक सार्वजनिक उपयोगिता की तरह।

जहाँ विरोधी-मत टूटता है

अब वह वापसी, क्योंकि यह दावा ईमानदार स्ट्रेस-टेस्ट का हकदार है। स्वतंत्र checkers उतने स्वतंत्र नहीं हैं जितना प्रचार सुझाता है। वे एक ही metatheory साझा करते हैं, उनमें से कई का डिज़ाइन एक ही वंश से आता है, और checker लेखक आपस में बात करते हैं; प्रोग्रामिंग भाषा की विविधता तर्क की विविधता नहीं है। फिसलन का उदाहरण भी पहले मिल चुका है: Collatz conjecture का एक गढ़ा हुआ खंडन एक ऐसे ही स्वतंत्र checker को पार कर गया था, इससे पहले कि किसी ने पकड़ा। विश्वास के तर्क का ईमानदार रूप वही है जो एक सावधान पर्यवेक्षक ने दिया: यह proof गलत होने के लिए एक ही बग को एक साथ checkers की आंतरिक consistency proofs और इस खास proof, दोनों को प्रभावित करना होगा, हर implementation में। बेहद कम संभावना है। पर 'बेहद कम' एक संभाव्यता है, और समुदाय का statement 'पूर्ण विश्वास' कहता है, जो एक समाजशास्त्र है।

एक मानवीय भार-वाहक दीवार भी है जिसका ज़िक्र चार प्रकाशित मानदंड नहीं करते। सबके अनुसार यह proof भारी AI सहायता से बना, और Alpöge ने दिशा दी: समस्या को विभाजित करना, मृत-अंत पहचानना, और जानना कि कौन-सा lemma गड़बड़ लगता है। वह मानवीय विशेषज्ञता असली epistemic काम कर रही है, और लिखा हुआ प्रमाणपत्र उस पर बिल्कुल निर्भर नहीं दिखता, जो मुझे परेशान करता है। मैं पहले LLM द्वारा conjecture बनाने और यांत्रिक proof-checking के बीच के बँटवारे पर लिख चुका हूँ, और यह उसी बँटवारे का अधिकतम दांव वाला रूप है: मशीन ने अभूतपूर्व पैमाने पर प्रस्ताव रखे, मशीन ने अभूतपूर्व पैमाने पर जाँचा, और एक दुर्लभ इंसान इस संधि-बिंदु पर बैठकर पूरी चीज़ को पठनीय बना रहा था। आधिकारिक कहानी से उस इंसान को हटा देने से कहानी साफ़ तो लगती है, पर सच्ची कम रह जाती है।

मशीन-जाँचे गए सॉफ़्टवेयर के लिए इंजीनियरिंग सबक

  • Trusted computing base को छोटा और उबाऊ रखें। हर कोड जिस पर आपको भरोसा करना पड़े, वह एक देनदारी है; हर कोड जिसे आप केवल जाँचते हैं, वह डेटा है।
  • एक निष्क्रिय, पोर्टेबल format में export करें। सत्यापन एक दस्तावेज़ पर चलना चाहिए, किसी लाइव process पर नहीं जो अप्रत्याशित चीज़ें execute कर सके।
  • सिर्फ़ तर्क नहीं, दावे को भी सत्यापित करें। comparator बनाएँ। proof का जश्न मनाने से पहले साबित करें कि आपका artifact contract से मेल खाता है।
  • Checkers में सचमुच विविधता लाएँ। अलग भाषाएँ मदद करती हैं; अलग foundations उससे भी ज़्यादा मदद करते हैं; consistency proof वाला एक checker, एक-दूसरे का homework नकल करने वाले दो checkers से बेहतर है।
  • Builds को reproducible और artifacts को content-addressable बनाएँ। 'दर्जनों लोगों ने वही export file दोबारा बनाई' ऐसा वाक्य है जिसकी हर release pipeline को आकांक्षा रखनी चाहिए।
  • बड़े योगदान से पहले साझा शब्दावली को upstream में मानक बनाएँ। पहले definitions, फिर वीरता।
  • अपनी धारणाओं को यांत्रिक रूप से गिनें। अगर आपका सिस्टम यह नहीं बता सकता कि 'वह किन चीज़ों पर निर्भर है?', तो आप नहीं जानते कि आपने क्या ship किया।

इस सूची के नीचे एक ही विचार है: tests एक space का नमूना लेते हैं, proofs उसे पूरी तरह खंगालते हैं, और बीच का दिलचस्प इलाका, जैसे property-based testing, model checking और symbolic execution, इंडस्ट्री धीरे और अनिच्छा से पहले खेमे से दूसरे की ओर रेंग रही है। कोई आपसे अपने CRUD ऐप को formalize करने को नहीं कह रहा। पर 'मशीन-जाँच अनिवार्य' की सीमा लगातार खिसक रही है: cryptographic primitives, consensus protocols, smart contracts, flight software, kernel eBPF verifiers। इनमें से हर समुदाय का अपना 'हमें सचमुच यह Lean वाले तरीके से करना चाहिए' वाला क्षण आया है, आमतौर पर किसी महँगी घटना के ठीक बाद। Riemann सत्यापन इस बात का प्रदर्शन है कि टूलिंग, संस्कृति और checker पारिस्थितिकी तंत्र सचमुच विशाल चीज़ का भार उठा सकते हैं। बहाने की अलमारी खाली है।

सौ साल की कोशिश

एक भाषा-प्रेमी के नाते मैं इसे एक बहुत पुराने दाँव के फल के रूप में देखे बिना नहीं रह सकता। Hilbert ने 1900 में Riemann Hypothesis को अपनी सूची में रखा। De Bruijn ने 1967 में Automath शुरू किया। Robin Milner ने 1970 के दशक में ML को खास तौर पर proof tactics लिखने के metalanguage के रूप में बनाया, और पूरा ML परिवार, जो OCaml और Haskell से होता हुआ Rust के type system तक पहुँचता है, मशीन-जाँचे गए proof के tooling से निकला है। 1990 के दशक का QED manifesto पूछता था कि पूरा गणित अब तक formalize क्यों नहीं हुआ, और ज़्यादातर लोगों ने कंधे उचकाए। फिर Four Colour Theorem Coq में गया, फिर Feit–Thompson theorem, फिर Liquid Tensor Experiment ने साबित किया कि आधुनिक शोध-गणित, सिर्फ़ क्लासिक नहीं, kernel के संपर्क में टिक सकता है। इनमें से हर एक को किसी ने 'स्टंट' कहा। हर एक ने समुदाय को प्रशिक्षित किया और उस लाइब्रेरी को मज़बूत किया जिस पर अगला खड़ा हुआ।

तो क्या मेरा शुरुआती दावा सही है? आंशिक रूप से। गणितज्ञों को एक theorem मिला, और सुबह तक वे पहले ही बेहतर सवाल पूछ रहे थे: यह proof सिखाता क्या है, जो सत्रह मिलियन जाँची हुई लाइनें अपने-आप नहीं सिखातीं। इंजीनियरों को कुछ दुर्लभ मिला: अधिकतम जाँच के तहत सत्यापित एक blueprint, ऐसे artifacts बनाने का जिन्हें कोई इंसान पढ़ नहीं सकता, और फिर भी समुदाय की साख उन पर दाँव पर लगाने का। अगली बार जब किसी design review में कोई कहे कि असली verification स्केल नहीं करता, तो आप ठीक जानेंगे कि उसे कौन-सा build log दिखाना है।