अपने क्वांटम प्रोसेसर को जानने के लिए

क्वांटम कंप्यूटर क्वैब से निर्मित होते हैं। लेकिन सिर्फ बहुत सारी मात्राएँ होना ही काफी नहीं है।

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

त्रुटियों की प्रकृति भी एक महत्वपूर्ण कारक है। क्वांटम कंप्यूटिंग के निकट अवधि के युग में, कुछ भी एकदम सही नहीं होगा। इसलिए हमें यह जानने की जरूरत है कि किस प्रकार की त्रुटियां होंगी, वे कितनी संभावित हैं, और क्या उन अनुप्रयोगों में उनके प्रभावों को कम करना संभव है, जिनके बारे में वे परवाह करते हैं।

क्वांटम डिवाइस के ये तीन सबसे महत्वपूर्ण पहलू हैं: क्वबिट नंबर, कनेक्टिविटी और नॉइज़ लेवल। क्वांटम कंप्यूटर क्या कर सकता है, इसका कोई भी अंदाजा लगाने के लिए आपको उन सभी को जानना होगा।

तो चलिए एक गेम बनाते हैं जो क्वांटम डिवाइस पर चलता है और इन सभी चीजों को सीधे दिखाता है। सिर्फ गेम खेलने से, खिलाड़ी वास्तव में देखेगा कि डिवाइस कितना बड़ा और कनेक्टेड है। एक सिम्युलेटर पर एक असली डिवाइस पर एक रन की तुलना करके, वे वास्तव में देखेंगे कि शोर कितना शक्तिशाली है। फिर कुछ त्रुटि शमन के साथ फिर से खेलने से, उन्हें इस बात का अंदाजा हो जाएगा कि थोड़े से शोर वाले क्वांटम कंप्यूटर के युग में भी कितनी उपयोगी जानकारी को बचाया जा सकता है। हम इस गेम को क्वांटम Awesomeness कहेंगे, और हम इसे 'ibmq_16_melbourne' नामक आईबीएम डिवाइस पर खेलेंगे।

ऊपर की छवि मेलबोर्न डिवाइस में क्या हो रहा है, इसके लिए एक त्वरित मार्गदर्शिका देता है। 14 मंडल हैं, जिनकी संख्या 0 से 13 तक है, जो रंगीन मंडलियों द्वारा दिखाए गए हैं। एक नियंत्रित संचालन के माध्यम से एक-दूसरे से बात कर सकने वाले बटनों को लाइनों द्वारा जुड़ा हुआ दिखाया गया है, जिनमें से प्रत्येक को नाम के लिए एक पत्र दिया गया है।

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

सबसे सरल प्रकार के उलझाव में सिर्फ दो क्वैबिट शामिल हैं। यह प्रत्येक को ऐसे आउटपुट देने का कारण होगा जो यादृच्छिक हैं, लेकिन उनके बीच सहसंबंध के साथ। उदाहरण के लिए, कुछ क्वैट्स पर निम्नलिखित प्रोग्राम पर विचार करें।

यह एक सर्किट आरेख है: हमारे कार्यक्रम में बटेरों का इतिहास बाएं से दाएं को बताया गया है।

यहां हम कोण perform / 2 के लिए एक आरएक्स ऑपरेशन करते हैं, जिसके परिणामस्वरूप अनिवार्य रूप से आधा एक्स गेट होता है। यह एक उदाहरण है जिसे हमने बैटलशिप में आंशिक रूप से गेट्स गेम के साथ 'आंशिक नहीं' कहा है। इसके बजाय क्विट को सभी तरह से फ़्लिप करने के बजाय। 0⟩ से लेकर 1 qu तक, यह इसे क्वांटम सुपरपोज़िशन राज्य के बीच में पार्क करता है।

दोनों खण्डों पर कार्य करने वाला ऑपरेशन एक नियंत्रित-नहीं है, जो नॉट टू डाउन क्वाट केवल तभी लागू होता है जब शीर्ष एक राज्य में हो | 1 qu | चूँकि ऊपर वाला दोनों संभावनाओं के एक सुपरपोज़िशन में है, नियंत्रित-नहीं का प्रभाव सुपरपोज़िशन को नीचे की क्विट में भी फैलाना है: दोनों का संयुक्त सुपरपोज़िशन | 0⟩ और दोनों | 1⟩ |

सर्किट का अंतिम भाग प्रत्येक क्वाइब से एक साधारण बिट निकालने के लिए होता है: | 0 0 0 हो जाता है; 0⟩ 1 हो जाता है, और एक सुपरपोज़िशन एक या दूसरे का यादृच्छिक विकल्प बन जाता है। लेकिन भले ही दोनों qubits इस मामले में एक यादृच्छिक परिणाम देंगे, लेकिन वे हमेशा सहमत हैं।

इसे सत्यापित करने के लिए, आइए इसे चलाते हैं। मुझे जो परिणाम मिला, वह था,

{[11 ’: ५०३, '00’: ५२१}

कार्यक्रम के लिए चलाए गए 1024 नमूनों में से, सभी परिणाम या तो `00` या` 11` थे। और हमारे पास प्रत्येक के लिए लगभग समान नमूने हैं। जैसा कि सभी ने भविष्यवाणी की है।

Π / 2 के मान को बदलकर हम सुपरपोज़िशन की प्रकृति को बदल सकते हैं। एक कम मान 0 के आउटपुट के लिए अधिक पक्षपाती परिणाम उत्पन्न करेगा, और result के करीब मूल्य 1s के प्रति पूर्वाग्रह में परिणाम देगा। इसका मतलब है कि हम उस संभावना को अलग-अलग कर सकते हैं जिसके साथ प्रत्येक आउटपुट 1 देगा। लेकिन हम जो भी मूल्य चुनते हैं, सर्किट का यह रूप यह सुनिश्चित करता है कि दो बटेरों के लिए परिणाम हमेशा सहमत होंगे।

इस गेम में हम डिवाइस में उलझे हुए इन जोड़ियों में से बहुत से जोड़े बनाएंगे। ऐसा करने के लिए, हमें सबसे पहले एक-दूसरे के साथ मोनोग्रामस (संभवतः कुछ बचे हुए लोगों को छोड़कर) को जोड़ी बनाने का एक तरीका चुनना होगा। यह जोड़ी बेतरतीब ढंग से चुनी जाएगी, और खेल का पूरा बिंदु खिलाड़ी के लिए यह अनुमान लगाने के लिए है कि जोड़ी क्या थी।

एक बार हमारे पास रैंडम पेयरिंग होने के बाद, हम मूल रूप से प्रत्येक स्वतंत्र पेयर पर ऊपर क्वांटम प्रोग्राम चलाएंगे। हालांकि हम एक अंतर पेश करेंगे: प्रत्येक जोड़ी के लिए हम बेतरतीब ढंग से आरएक्स ऑपरेशन के लिए एक अलग मूल्य चुनेंगे, इसलिए युग्मित क्वैब द्वारा साझा किए गए यादृच्छिकता की डिग्री जोड़ी से जोड़ी में भिन्न होगी।

जब हम सर्किट को चलाते हैं, तो परिणाम 14 बिट्स की एक स्ट्रिंग होगी: प्रत्येक बिट के साथ प्रत्येक क्वेट के आउटपुट का वर्णन करना। चूंकि हम आंकड़े लेने के लिए इसे कई नमूनों के लिए चलाते हैं, इसलिए पूर्ण परिणाम उन सभी बिट स्ट्रिंग्स की एक सूची होगी जो प्रत्येक बार होने वाले समय के साथ-साथ निकले।

चूंकि खेल का उद्देश्य खिलाड़ी द्वारा आउटपुट से जोड़ी को कम करना है, इसलिए हम उन सभी डेटा को उन पर डंप कर सकते हैं। लेकिन यह शायद बहुत मजेदार नहीं होगा। इसके बजाय, हम सिर्फ महत्वपूर्ण बिंदुओं पर ध्यान केंद्रित कर सकते हैं:

  • 0 के बजाय 1 के आउटपुट देने वाले प्रत्येक क्वाइब की संभावना क्या है?
  • क्या संभावना है कि कनेक्टेड क्वाइबल्स की प्रत्येक जोड़ी समान मूल्य देती है?

फिर हम उस जानकारी को डिवाइस की अपनी छवि पर डाल सकते हैं। उदाहरण के लिए, यहां रन का एक विशेष सेट है।

प्रत्येक qubit पर प्रदर्शित संख्या नमूनों का प्रतिशत है जिसके लिए परिणाम 1 था। प्रत्येक कनेक्शन पर संख्या नमूनों का प्रतिशत है, जिसके लिए इसी जोड़ी के जोड़े ने असहमति व्यक्त की थी। इस जानकारी के साथ, हम आसानी से उलझी हुई क्वाइबेट्स के जोड़े को पा सकते हैं: या तो उन कॉबिट्स की तलाश करके जो 1 को आउटपुट करने की समान संभावना को साझा करते हैं, या उन जोड़ों को ढूंढते हैं जो कभी असहमत नहीं थे।

उपरोक्त डेटा एक सिम्युलेटर से निकाला गया था। अब इसे वास्तविक क्वांटम डिवाइस पर आजमाते हैं।

यहाँ परिणाम इतने स्पष्ट नहीं हैं जितना कि सिम्युलेटर के लिए। शोर के प्रभाव अधिक मजबूत होते हैं, जिससे जोड़ों की पहचान करना बहुत कठिन हो जाता है।

पर अभी भी सब कुछ खत्म नहीं हुआ! हम कुछ त्रुटि शमन कर सकते हैं। हम जानते हैं कि आउटपुट में एक निश्चित संरचना होनी चाहिए, इसलिए हम उस संरचना को खोज सकते हैं और परिणाम को साफ करने के लिए इसका उपयोग कर सकते हैं।

यहाँ यह करने के लिए एक बहुत ही सरल तरीका है। सबसे पहले, प्रत्येक qubit अपने सभी पड़ोसियों को देखेगा और देखेगा कि वह किसके साथ सहमत है। इसके बाद यह मान लिया जाएगा कि यह सबसे ज्यादा सहमत होने वाला क्वेट इसका साथी है। इसके परिणामों में त्रुटियों को आज़माने और संतुलित करने के लिए, हम तब उन दोनों के लिए औसत के साथ उस qubit के लिए 1 का आउटपुट प्राप्त करने की संभावना को बदल देंगे।

हालांकि चीजें बेहतर हुई हैं, लेकिन वे किसी भी तरह से सही नहीं बने हैं। इसका कारण यह है कि हमारी त्रुटि शमन योजना बहुत सरल है, और प्रक्रिया के अंत में सिर्फ बोल्ट किया गया है। त्रुटि शमन में शक्तिशाली प्रभाव हो सकते हैं, लेकिन यह सबसे प्रभावी है जब इसे क्वांटम प्रोग्राम में बनाया जाता है (कुछ आप अपने साथ प्रयोग करने की कोशिश कर सकते हैं यदि आप इस परियोजना पर विस्तार करना चाहते हैं)।

अभी के लिए, चलो बस इन कम परिणामों का उपयोग करके खेल खेलते हैं।

हमारा काम है कि हम संख्याओं को देखें, और ऐसे जोड़ों को खोजने की कोशिश करें जिनमें या तो समान संख्या हो या कम से कम ऐसी संख्याएँ हों जो यथासंभव समीप हों। बाईं ओर दो 48s एक अच्छी शुरुआत की तरह लग रहे हैं। तो आइए जोड़ी ए के लिए जाएं, जैसा कि हम सोचते हैं कि आप उलझ गए हैं।

जोड़ी एच के दोनों 46 एक दूसरे के समान हैं, और उनके पड़ोसियों से भी काफी अलग हैं। तो हम उस एक के लिए भी जाएंगे।

फिर जोड़ी ई बहुत निश्चित लगती है।

और जोड़ी सी।

अब हम एक ऐसे बिंदु पर पहुँच गए हैं जहाँ शोर करना हमारे लिए थोड़ा कठिन है। क्या 42 को 55, या 56 के साथ जोड़ा जाना चाहिए? चूंकि 55 मूल्य के करीब है, हम जोड़ी ओ के लिए जाएंगे।

अंत में हम दो खदानों के साथ रह गए हैं जिन्हें कुछ नहीं के साथ जोड़ा जाना चाहिए था। इस डिवाइस पर हमेशा ऐसा होगा कि जिस तरह से इसका कनेक्टिविटी ग्राफ संरचित है। तो हम समाधान तक पहुँच गए हैं! लेकिन क्या यह सही था?

चलिए फिर से नीरव सिमुलेशन पर नज़र डालते हैं, जहाँ सही जोड़ी को देखना बहुत आसान था।

जो जोड़े यहां सही समझौता दिखाते हैं, वे ठीक वही हैं जिन्हें हमने अभी चुना था। इसलिए हम वास्तव में सही थे। हमने क्वांटम कंप्यूटर पर एक गेम खेला, और हम जीत गए!

आगे क्या?

यदि आप क्वांटम प्रोग्रामिंग के साथ शुरुआत करना चाहते हैं, तो इस गेम के लिए स्रोत कोड पर एक नज़र क्यों नहीं रखना चाहिए, जो किस्किट ट्यूटोरियल पर उपलब्ध है।

हमने आपके द्वारा इसे विस्तारित करने के तरीकों के लिए भी कुछ विचार एकत्र किए हैं

  • गेम खेलने के लिए एक एल्गोरिथ्म लिखें। यह डेटा के विश्लेषण का चतुराई से विश्लेषण करके जोड़े को जितना संभव हो उतना सही होगा।
  • जब कोई शोर न हो तो पहेली को हल करना बहुत आसान है। आप विभिन्न कठिनाई स्तर पेश कर सकते हैं।
  • यहाँ उपयोग किया जाने वाला त्रुटि शमन बहुत सरल है। आप इस वार्ता में वर्णित 'अधिक मजबूत चरण अनुमान' जैसे कुछ और परिष्कृत कार्यान्‍वयन करने का प्रयास कर सकते हैं।
  • क्या अधिक जटिल उलझी हुई अवस्थाएँ, जैसे कि तीन बटेर वाले होते हैं, का उपयोग यह सुनिश्चित करने के लिए किया जा सकता है कि किसी उपकरण पर कोई भी क्वांट मज़े से न छूटे?

इस और हमारे अन्य क्वांटम गेम के साथ मज़े करो!