Representation-Dependent Recoverability in Quantum Compilation

आज की मशीनों के लिए असंभव समस्याओं को हल करने वाले कंप्यूटर बनाने की खोज में, वैज्ञानिक क्वांटम प्रोसेसर बनाने की दौड़ में लगे हैं। ये उपकरण क्वांटम मैकेनिक्स के विचित्र नियमों का उपयोग करके सूचनाओं को उस तरह से रखने और संसाधित करने के लिए करते हैं जो क्लासिकल कंप्यूटर नहीं कर सकते। हालाँकि, इन मशीनों को उपयोगी बनाने के लिए, उन्हें मामूली पर्यावरणीय शोर (environmental noise) से बचाना होगा, जो त्रुटियों का कारण बनता है। जीवित रहने के लिए, एक क्वांटम कंप्यूटर को त्रुटि सुधार (error correction) की एक विशाल परत की आवश्यकता होती है, जो लगातार डेटा की जाँच और सुधार करती रहे। यह सुरक्षा एक भारी कीमत पर आती है: इसके लिए एक एकल तार्किक ऑपरेशन (logical operation) को करने के लिए भारी मात्रा में भौतिक हार्डवेयर और समय की आवश्यकता होती है। एक उच्च-स्तरीय एल्गोरिदम और इस नाजुक, त्रुटि-सुधार वाले हार्डवेयर के बीच का सेतु एक कंपाइलर है, जो एक सॉफ्टवेयर अनुवादक है जो अमूर्त निर्देशों को उन विशिष्ट, निम्न-स्तरीय पल्स (pulses) में परिवर्तित करता है जिन्हें मशीन समझती है। इस अनुवाद की दक्षता यह निर्धारित करती है कि एक क्वांटम गणना व्यवहार्य है या असंभव।

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

शोधकर्ताओं ने क्वांटम कंप्यूटिंग के एक सामान्य परिदृश्य पर ध्यान केंद्रित किया जहाँ एक एकल गणितीय ऑपरेशन को निष्पादन के कई दौरों (rounds) में विभाजित किया जाता है। ऐसा अक्सर तब होता है जब किसी प्रोग्राम को त्रुटियों को कम करने के लिए रैंडमाइज किया जाता है या जब इसे हार्डवेयर बाधाओं को फिट करने के लिए समय के अनुसार शेड्यूल किया जाता है। इन मामलों में, ऑपरेशन का कुल प्रभाव ऑपरेशन के बिखरे हुए हिस्सों में छिपा होता है। कंपाइलर के लिए, यह असंबंधित टुकड़ों की एक धारा की तरह दिखता है। सही परिणाम प्राप्त करने के लिए, कंपाइलर को यह पता लगाना होगा कि ये टुकड़े आपस में कैसे जुड़ते हैं। टीम ने इस समस्या को औपचारिक रूप दिया जिसमें कंपाइलर को एक ऐसी मशीन माना गया जिसे या तो स्ट्रीम को पढ़ते समय अपनी आंतरिक मेमोरी में बिखरी हुई जानकारी को स्टोर करना होगा, या पूरी कड़ियों को देखने से पहले अंतिम उत्तर लिखने के लिए प्रतिबद्ध होना होगा।

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

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

अध्ययन ने एक विशेष कार्य करने के तरीके के लिए एक विशिष्ट दंड (penalty) का भी खुलासा किया। यदि एक कंपाइलर आउटपुट का एक हिस्सा लिखता है और फिर बाकी निर्देशों को पढ़ने से पहले तुरंत उसे क्वांटम मशीन पर लागू करता है, तो उसे एक अतिरिक्त टैक्स देना पड़ता है। यह टैक्स उस जानकारी को समझने की लागत है कि वह वास्तव में प्रोग्राम के किन हिस्सों पर कार्य कर रहा है, जो जानकारी मुफ्त होती है यदि कंपाइलर पहले निर्देशों को पढ़ ले और फिर प्रतीक्षा करे। यह निष्कर्ष बताता है कि वास्तविक दुनिया के क्वांटम सिस्टम में, जहाँ निर्देश अक्सर वास्तविक समय में लागू किए जाते हैं, कुछ प्रकार की अनुकूलन रणनीतियों के लिए एक अनिवार्य ओवरहेड होता है।

शोधकर्ताओं ने फिर इन निष्कर्षों को अगले स्तर पर ले जाने के लिए उन्हें सिम्युलेट किया कि यह सूचना लागत भौतिक हार्डवेयर आवश्यकताओं में कैसे परिवर्तित होती है। उन्होंने यह देखने के लिए एक मानक मॉडल का उपयोग किया कि अतिरिक्त डेटा बोझ ने भौतिक घटकों की संख्या को कैसे प्रभावित किया। परिणाम नाटकीय थे। एक पाइपलाइन जिसने जानकारी को बिखरा हुआ रखा और भागों को अलग-अलग संश्लेषित (synthesize) किया, उसे उस पाइपलाइन की तुलना में हजारों गुना अधिक भौतिक संसाधनों—विशेष रूप से, अधिक "मैजिक स्टेट्स" और अधिक समय—की आवश्यकता थी, जिसने पहले जानकारी को एक एकल, सघन (compact) रूप में एकत्र किया था। एक विशिष्ट परीक्षण मामले में, बिखरे हुए दृष्टिकोण को सघन दृष्टिकोण की तुलना में 2,800 गुना से अधिक स्पेस-टाइम वॉल्यूम की आवश्यकता थी। इसका अर्थ है कि एक कंपाइलर जो प्रोग्राम की बिखरी हुई संरचना को पहचानने और पुनर्गठित करने में विफल रहता है, वह किसी गणना को असंभव बना सकता है क्योंकि वह अधिक हार्डवेयर की मांग करता है।

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

शोधकर्ताओं ने वास्तविक दुनिया के एल्गोरिदम, जैसे कि अनुकूलन (optimization) और सिमुलेशन के लिए उपयोग किए जाने वाले एल्गोरिदम के विरुद्ध भी अपने विचारों का परीक्षण किया। हर मामले में, उस दृष्टिकोण ने जो समस्या की सिमेंटिक संरचना (semantic structure) को संरक्षित करता था—कोड के "अर्थ" को बरकरार रखता था—अधिक कुशल परिणाम दिए, जो उन दृष्टिकोणों से बेहतर थे जिन्होंने कोड को निर्देशों की एक सपाट सूची के रूप में माना। यहाँ तक कि शक्तिशाली, मौजूदा सॉफ्टवेयर टूल्स का उपयोग करते हुए भी, वे टूल्स जो अंतर्निहित संरचना को पुनर्गठित कर सकते थे, काफी बेहतर प्रदर्शन करते थे। यह पुष्टि करता है कि लैब में खोजे गए सैद्धांतिक सीमाएं केवल अमूर्त गणित नहीं हैं बल्कि उनके प्रत्यक्ष, मापने योग्य परिणाम हैं।

अंततः, यह शोध भविष्य के क्वांटम कंपाइलर के डिजाइन के लिए एक स्पष्ट नियम प्रदान करता है। यह इंजीनियरों को बताता है कि वे केवल कोड को छोटे टुकड़ों में तोड़कर अनुकूलित नहीं कर सकते बिना एक कीमत चुकाए। यदि वे जानकारी को बिखेरते हैं, तो उन्हें डेटा का भारी बोझ ढोने या कोड की एक विशाल मात्रा लिखने के लिए तैयार रहना चाहिए। सबसे कुशल मार्ग जानकारी को यथासंभव एकत्रित (aggregated) रखना है। यह अंतर्दृष्टि उन सॉफ्टवेयर स्टैक को बनाने के लिए एक ठोस मार्गदर्शिका प्रदान करती है जो एक दिन दुनिया के पहले वास्तव में उपयोगी क्वांटम कंप्यूटरों पर चलेंगे, यह सुनिश्चित करते हुए कि इन मशीनों की अपार क्षमता अनुवाद की अक्षमताओं के कारण नष्ट न हो जाए।