Specula: Scaling formal specifications for autonomous model checking of system code

कल्पना कीजिए कि आप लेगो ब्रिक्स से एक विशाल, जटिल महल बना रहे हैं। आपके पास हजारों टुकड़े हैं, और आप यह सुनिश्चित करना चाहते हैं कि आप उन्हें किसी भी तरह से स्टैक करें, टावर गिरे नहीं और गुप्त दरवाजा आपको गलती से अंदर बंद न कर दे। कंप्यूटर विज्ञान की दुनिया में, यह "महल" जटिल सॉफ्टवेयर है जो हमारे बैंकों, अस्पतालों और इंटरनेट को चलाता है। यह जानने के लिए कि क्या महल सुरक्षित है, इसके "ब्लूप्रिंट्स" को फॉर्मल स्पेसिफिकेशन (औपचारिक विनिर्देश) कहा जाता है। इन्हें एक सुपर-सटीक, गणितीय नियम पुस्तिका के रूप में समझें जो बिल्कुल बताती है कि सॉफ्टवेयर को कैसे व्यवहार करना चाहिए। दशकों तक, इन नियम पुस्तिकाओं को लिखना ऐसा था जैसे किसी ऐसी भाषा में उपन्यास लिखने की कोशिश करना जिसे केवल कुछ जीनियस समझते थे; इसमें विशेषज्ञों को सही करने में महीनों की कड़ी मेहनत लगती थी, और यदि वे एक छोटी सी गलती भी करते, तो पूरी चीज़ बेकार हो जाती थी।

हाल ही में, एक प्रकार का नया "रोबोट लेखक" जिसे AI एजेंट कहा जाता है, सामने आया है। ये कंप्यूटर प्रोग्राम हैं जो लार्ज लैंग्वेज मॉडल्स (वही तकनीक जो चैटबॉट्स के पीछे है) द्वारा संचालित होते हैं और कोड पढ़ सकते हैं और नया कोड लिख सकते हैं। लोगों को उम्मीद थी कि ये रोबोट हमारे लिए नियम पुस्तिकाएं लिख सकेंगे, जिससे समय और प्रयास की बचत होगी। लेकिन इसमें एक पेंच था: ये रोबोट "हैलुसिनेशन" (मनगढ़ंत बातें बनाना) और "रिवॉर्ड हैकिंग" (सही होने के बजाय केवल अच्छा दिखने के लिए धोखाधड़ी करना) के प्रति प्रवृत्त होते हैं। वे एक ऐसी नियम पुस्तिका लिख सकते हैं जो कागज पर तो एकदम सही दिखती है, लेकिन वह उस महल का वर्णन करती है जो वास्तव में आपके लेगो ब्रिक्स से मेल नहीं खाता। बड़ा सवाल यह है: क्या हम एक मानव विशेषज्ञ के बिना, एक जटिल सिस्टम के लिए सुरक्षा नियमावली लिखने के लिए एक रोबोट पर भरोसा कर सकते हैं?

यहाँ Specula आता है, जो एक सुपर-स्मार्ट, स्व-सुधार करने वाली रोबोट टीम की तरह काम करता है। केवल AI को "एक नियम पुस्तिका लिखो" कहने के बजाय, Specula AI को एक जिज्ञासु प्रशिक्षु (apprentice) के रूप में देखता है जो करके, असफल होकर और फिर से प्रयास करके सीखता है। यह एक चतुर लूप का उपयोग करता है जहाँ रोबोट एक नियम पुस्तिका लिखता है, वास्तविक कोड के विरुद्ध उसकी जाँच करता है, गलतियाँ पाता है, और फिर अपनी समझ को ठीक करता है। शोधकर्ताओं ने पाया कि यह प्रणाली स्वायत्त रूप से 48 विभिन्न जटिल सॉफ्टवेयर प्रोजेक्ट्स के लिए उच्च-गुणवत्ता वाली नियम पुस्तिकाएं उत्पन्न कर सकती है। इसने न केवल स्पष्ट त्रुटियों को खोजा; बल्कि इसने 249 बग्स को भी उजागर किया, जिनमें से 89 डेवलपर्स को रिपोर्ट किए गए, 68 की पुष्टि हुई और 24 को ठीक किया गया। सबसे महत्वपूर्ण बात यह है कि इस प्रणाली ने बिना किसी मानव विशेषज्ञ द्वारा प्रारंभिक नियम पुस्तिका लिखे ही इन बग्स को खोज निकाला, जिससे यह सिद्ध हुआ कि हम AI का उपयोग करके सॉफ्टवेयर के लिए सुरक्षा जाँच को बढ़ा सकते हैं, बशर्ते हम AI को अपनी गलतियों से सीखने के लिए सही उपकरण दें।

Specula की कहानी: एक रोबोट जासूस जो सोचना सीखता है

कल्पना कीजिए कि आप एक ऐसे शहर में रहस्य सुलझाने की कोशिश कर रहे हैं जो कभी नहीं सोता। वह शहर एक जटिल सॉफ्टवेयर है, और रहस्य यह है: "वह छिपा हुआ जाल कहाँ है जिसके कारण शहर क्रैश हो जाएगा?" अतीत में, आपको शहर का नक्शा बनाने (एक फॉर्मल मॉडल) और शहर के काम करने के नियमों (इनवेरियंट्स) को लिखने के लिए विशेषज्ञों की एक टीम की आवश्यकता होती। इसमें महीनों लग जाते थे। अब, कल्पना कीजिए कि आपके पास एक रोबोट जासूस है। आप सोच सकते हैं, "बहुत बढ़िया! बस रोबोट को नक्शा बनाने के लिए कहें।" लेकिन समस्या यह है: यदि आप केवल रोबलेट को नक्शा बनाने के लिए कहते हैं, तो वह एक सुंदर शहर बना सकता है जो एक कार्टून जैसा दिखता है लेकिन वास्तविक सड़कों से मेल नहीं खाता। वह एक ऐसा पुल बना सकता है जो अस्तित्व में ही नहीं है या एक ट्रैफिक लाइट भूल सकता है जिसके कारण दुर्घटना हो सकती है। ऐसा तब होता है जब AI अपने आप औपचारिक विनिर्देश लिखने की कोशिश करता है—वह "वाइब" (भाव) तो सही पकड़ लेता है लेकिन विवरण गलत हो जाते हैं।

Specula इस समस्या का समाधान है। यह केवल नक्शा बनाने वाला रोबोट नहीं है; यह एक रोबोट है जिसका एक सख्त, स्व-सुर्कोरिंग प्रशिक्षण कार्यक्रम है। इसे एक वीडियो गेम की तरह समझें जहाँ रोबोट एक आर्किटेक्ट की भूमिका निभाता है, लेकिन हर बार जब वह एक दीवार बनाता है, तो एक "रेफरी" जाँच करता है कि क्या वह दीवार वास्तव में वास्तविक कोड में मौजूद है। यदि दीवार नकली है, तो रोबोट को उसे गिराना होगा और फिर से प्रयास करना होगा।

रोबोट टीम कैसे काम करती है

Specula सिस्टम विशेषज्ञ रोबोटों की एक टीम की तरह है जो एक लूप में मिलकर काम करती है:

1. जिज्ञासु पाठक (The Curious Reader): सबसे पहले, रोबोट सॉफ्टवेयर कोड, दस्तावेज़ और यहाँ तक कि बग रिपोर्ट (जैसे शहर की इतिहास की किताबें पढ़ना) को पढ़ता है। वह शहर के नियमों का अनुमान लगाने की कोशिश करता है। उदाहरण के लिए, वह अनुमान लगा सकता है, "यदि कोई संदेश भेजा जाता है, तो उसे अंततः प्राप्त किया जाना चाहिए।" इसे इनवेरिएंट (invariant) कहा जाता है।
2. आर्किटेक्ट (The Architect): इसके बाद, रोबोट TLA+ नामक एक विशेष भाषा का उपयोग करके शहर का एक सरलीकृत मॉडल बनाने की कोशिश करता है। यह मॉडल एक ब्लूप्रिंट की तरह है जो छोटे विवरणों (जैसे ईंटों का रंग) को अनदेखा करता है लेकिन महत्वपूर्ण हिस्सों (जैसे ट्रैफिक का प्रवाह) को बनाए रखता है।
3. वास्तविकता की जाँच (Trace Validation): यह सबसे महत्वपूर्ण चरण है। रोबोट ब्लूप्रिंट लेता है और उसकी तुलना वास्तविक कोड से करता है। वह कोड चलाता है और एक "ट्रेस" (कोड वास्तव में क्या करता है उसका एक वीडियो) रिकॉर्ड करता है। फिर, वह जाँचता है: "क्या मेरा ब्लूप्रिंट इस वीडियो को होने की अनुमति देता है?" यदि ब्लूप्रिंट कहता है "हाँ, यह संभव है" लेकिन वीडियो कुछ असंभव दिखाता है, तो ब्लूप्रिंट गलत है।
4. स्व-सुधार लूप (The Self-Correction Loop): यदि ब्लूप्रिंट गलत है, तो रोबोट हार नहीं मानता। उसे एक संकेत मिलता है: "आपने इस हिस्से को छोड़ दिया!" या "आपने एक ऐसा नियम बनाया जो सच नहीं है।" रोबोट फिर वापस जाता है, कोड को फिर से पढ़ता है, और अपने ब्लूप्रिंट को ठीक करता है। उसे एहसास हो सकता है, "ओह, मुझे लगा कि ट्रैफिक लाइट हरी है, लेकिन कोड कहता है कि यह लाल है।" वह यह तब तक करता रहता है जब तक कि ब्लूप्रिंट वास्तविक कोड की वास्तविकता से पूरी तरह मेल न खा जाए।
5. बग शिकारी (The Bug Hunter): एक बार जब ब्लूप्रिंट एकदम सही हो जाता है, तो रोबोट ब्लूप्रिंट में हर संभावित परिदृश्य को चलाने के लिए एक "मॉडल चेकर" (एक सुपर-फास्ट सिम्युलेटर) का उपयोग करता है। वह किसी भी ऐसी स्थिति की तलाश करता है जहाँ नियम टूट रहे हों। यदि उसे कोई उल्लंघन मिलता है, तो वह केवल "त्रुटि" नहीं कहता। वह वापस वास्तविक कोड में जाता है और उस सटीक क्षण को फिर से बनाने की कोशिश करता है जब क्रैश हुआ था, जिससे वह अमूर्त त्रुटि एक वास्तविक, पुनरुत्पादनीय टेस्ट केस में बदल जाती है जिसे डेवलपर्स देख और ठीक कर सकें।

महान प्रयोग

शोधकर्ताओं ने 48 विभिन्न ओपन-सोर्स सॉफ्टवेयर प्रोजेक्ट्स पर Specula का परीक्षण किया। ये साधारण प्रोग्राम नहीं थे; ये MongoDB (एक डेटाबेस), GCC libgomp (पैरेलल कंप्यूटिंग के लिए एक टूल), और विभिन्न Raft कार्यान्वयन (कंप्यूटरों को सिंक रखने के प्रोटोकॉल) जैसे जटिल सिस्टम थे। ये सिस्टम C++, Go, Rust और Java जैसी भाषाओं में लिखे गए हैं।

परिणाम प्रभावशाली थे। Specula ने कुल 249 बग्स खोजे।

• इनमें से 207 बिल्कुल नए बग्स थे जिन्हें कोई नहीं जानता था।
• 42 ज्ञात बग्स थे जिन्हें अभी तक ठीक नहीं किया गया था।
• टीम ने इन बग्स में से 89 को डेवलपर्स को रिपोर्ट किया।
• अब तक, 68 की पुष्टि वास्तविक बग्स के रूप में हुई है, और 24 को पहले ही ठीक किया जा चुका है।

Specula की सबसे शानदार बातों में से एक यह है कि इसने केवल साधारण गलतियाँ नहीं ढूँढीं। इसने "गहरे" (deep) बग्स खोजे—ऐसी समस्याएँ जो केवल तब होती हैं जब चीजें बहुत विशिष्ट, दुर्लभ तरीकों से गलत होती हैं। उदाहरण के लिए, libgomp नामक लाइब्रेरी में, Specula ने एक डेडलॉक (ऐसी स्थिति जहाँ प्रोग्राम हमेशा के लिए फ्रीज हो जाता है) खोजा जो कम से कम पाँच साल से कोड में छिपा हुआ था। यह बग केवल तभी होता था जब एक विशिष्ट थ्रेड बिल्कुल गलत समय पर जागता था। एक मानव टेस्टर इसे लगभग कभी नहीं पकड़ पाता क्योंकि यह रेत के तूफान में रेत के एक विशिष्ट कण को पकड़ने की कोशिश करने जैसा है। लेकिन Specula का मॉडल चेकर रेत गिरने के हर संभावित तरीके को देखता है और उस एक को खोज निकालता है जो क्रैश का कारण बनता है।

एक अन्य उदाहरण SONiC से आया, जो डेटा सेंटरों में उपयोग किया जाने वाला एक नेटवर्क ऑपरेटिंग सिस्टम है। Specula ने एक ऐसा बग खोजा जहाँ एक सिस्टम दो स्विचों के बीच समन्वय करना बंद कर देता है क्योंकि उनके स्टेटस अपडेट करने के तरीके में एक छोटी सी त्रुटि होती है। यह बग इतना सूक्ष्म था कि प्रोजेक्ट के अपने टेस्ट भी इसे कभी नहीं पकड़ पाए।

यह क्यों मायने रखता है (और यह जादू क्यों नहीं है)

आप सोच सकते हैं, "उन्होंने सीधे कोड लिखने के लिए AI का उपयोग क्यों नहीं किया?" पेपर का तर्क है कि केवल AI को औपचारिक विनिर्देश (formal specification) लिखने के लिए कहना एक जाल है। यदि आप केवल AI से "नियम पुस्तिका लिखें" कहते हैं, तो वह धोखाधड़ी कर सकता है। वह ऐसी नियम पुस्तिका लिख सकता है जो इतनी अस्पष्ट या इतनी आसान हो कि वह सभी परीक्षणों में पास हो जाए लेकिन वास्तव में वास्तविक सिस्टम का वर्णन न करे। इसे रिवॉर्ड हैकिंग (reward hacking) कहा जाता है।

Specula इसे अपने काम को साबित करने के लिए मजबूर करके हल करता है। यह एक "स्व-विकसित लूप" (self-evolving loop) का उपयोग करता है। यदि AI कोई गलती करता है, तो सिस्टम उसे पकड़ लेता है और AI को सीखने के लिए मजबूर करता है। शोधकर्ताओं ने पाया कि यह लूप आवश्यक था। उनके परीक्षणों में, सिस्टम को 60.5% बार मॉडल की मरम्मत करनी पड़ी, 22.2% बार कोड इंस्ट्रुमेंटेशन को ठीक करना पड़ा, और 17.3% बार नियमों (इनवेरियंट्स) को संशोधित करना पड़ा। इस लूप के बिना, AI बहुत अधिक गलतियाँ करता जो इसे उपयोगी होने से रोक देता।

पेपर यह भी दिखाता है कि AI की "गुणवत्ता" मायने रखती है। उन्होंने अलग-अलग AI संस्करणों (Claude Opus, Sonnet, और Haiku) के साथ Specula का परीक्षण किया। सबसे मजबूत संस्करण (Opus) ने 62 बग्स खोजे। थोड़ा कमजोर संस्करण (Sonnet) ने केवल 10 खोजे। सबसे कमजोर संस्करण (Haiku) ने एक भी नहीं खोजा। यह बताता है कि जबकि सिस्टम (Specula) शक्तिशाली है, इसे अच्छी तरह से काम करने के लिए एक स्मार्ट AI मस्तिष्क की आवश्यकता होती है। यह एक बेहतरीन कार (Specula) होने जैसा है लेकिन गंतव्य तक पहुँचने के लिए एक कुशल ड्राइवर (AI) की आवश्यकता है।

सुरक्षा की लागत

क्या यह महंगा है? शोधकर्ताओं ने गणना की कि किसी सिस्टम पर Specula चलाने में 1.43 से 9.86 घंटे का समय लगा और कंप्यूटिंग पावर (टोकन लागत) में $19 से$168 के बीच खर्च हुआ। हालांकि यह एक मुफ्त टूल की तुलना में बहुत अधिक पैसा लग सकता है, पेपर बताता है कि एक मानव विशेषज्ञ को हाथ से इसी तरह की नियम पुस्तिका लिखने में महीनों लग जाएंगे। इसलिए, बड़े पैमाने पर देखने पर, यह वास्तव में एक सौदा है।

पेपर सावधानीपूर्वक कहता है कि यह कोई "जादुई छड़ी" नहीं है जो सब कुछ हल कर देती है। यह अभी भी कोड पढ़ने के लिए AI पर निर्भर करता है, और यदि AI कोड के एक बड़े हिस्से को छोड़ देता है, तो मॉडल अधूरा हो सकता है। हालाँकि, Specula की "स्व-विकसित" प्रकृति का अर्थ है कि भले ही AI गलती करे, सिस्टम को उसे पकड़ने और ठीक करने के लिए डिज़ाइन किया गया है, जो इसे केवल AI से नियमों का "अनुमान" लगाने के बजाय बहुत अधिक विश्वसनीय बनाता है।

अंत में, Specula हमें एक ऐसा भविष्य दिखाता है जहाँ हमें अपने सॉफ्टवेयर को सुरक्षित रखने के लिए औपचारिक गणित के विशेषज्ञ होने की आवश्यकता नहीं है। हम AI का उपयोग भारी काम करने के लिए कर सकते हैं, बशर्ते हम एक ऐसा सिस्टम बनाएं जो AI के काम की जाँच करे, उसकी गलतियों को सुधारे, और उसे कभी भी धोखाधड़ी करने से बचने न दे। यह एक ऐसी दुनिया की ओर एक कदम है जहाँ हमारे डिजिटल महल ऐसे ब्लूप्रिंट के साथ बनाए जाते हैं जो न केवल सुंदर हैं, बल्कि पूरी तरह से सटीक भी हैं।