क्वांटम कंप्यूटर कैसे प्रोग्राम करें - भाग 2

क्वांटम माप के साथ युद्धपोत

आईबीएम रिसर्च https://www.flickr.com/photos/ibm_research_zurich/33072160062/

इस लेख में अच्छे कारण के लिए शीर्षक में 'भाग 2' है। एक भाग 1 था, जिसमें हमने क्वांटम कार्यक्रमों को लिखने और चलाने के आधार पर देखा।

मैं यह मानकर चल रहा हूं कि आप यहां आने से पहले कम से कम पहली छमाही पढ़ेंगे।

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

कैसे क्वेटा को देखने के लिए

कार्यक्रमों में हमारे पास चर हैं। कुछ बिंदु पर हमें उन्हें देखने की आवश्यकता होगी।

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

ऐसा इसलिए है क्योंकि गैर-क्वांटम चर के निश्चित मूल्य हैं। उन्हें देखते हुए बस हमें, या कार्यक्रम के अन्य हिस्सों को बताता है कि मूल्य क्या है। चर के बारे में कुछ भी नहीं बदलेगा।

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

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

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

एक qubit की दुनिया मानचित्रण

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

राज्य 0 और 1 पूरी तरह से अलग हैं, पूरी तरह से असंतुष्ट हैं। वे एक-दूसरे के विरोधी हैं। इसलिए वे गोले के विपरीत पक्षों पर रहेंगे। हम आम तौर पर उत्तरी ध्रुव पर 0 और दक्षिण में 1 चुनते हैं।

आइए एक बिंदु उठाते हैं जो दोनों के बीच समतुल्य है, कहीं भूमध्य रेखा के साथ। यह आप की तरह कहीं भी हो सकता है। हम इसे कॉल करेंगे +। क्यों +? क्यों नहीं?

+ राज्य में एक विपरीत भी होता है, जैसा कि 0 से भिन्न होता है। 1. यह विपरीत दिशा में रहता है, जो भूमध्य रेखा के साथ एक बिंदु भी होगा। हम इस अवस्था को कहेंगे -

अंक 0, 1, + और - के साथ अब परिभाषित किया गया है, एक और जोड़ी बिंदु हमारे ध्यान के लिए भीख माँग रहे हैं। ये वे हैं जो 0 और 1 के बीच समान हैं, और + और - के बीच भी समान हैं। हम इन ↻ और ↻ को कॉल करेंगे। क्यों? क्योंकि मैंने एक बार एक आदमी को देखा था जिसने दा विंची कोड ऐसा नहीं लिखा था, और मुझे यह पसंद आया।

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

एक मात्रा मापने

कोई भी मापक हमें बस एक विचाराधीन क्षेत्र में दो विपरीत बिंदुओं के बीच चयन करने के लिए कह रहा है।

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

भूमध्य रेखा पर, यह 50/50 का मौका है। इसलिए यदि हमारा राज्य + या - था, और हम फिर पूछते हैं कि क्या यह 0 या 1 है, तो इसे एक या दूसरे को अनिवार्यता के साथ चुनना होगा।

0 और 1 पर आधारित माप में कुछ नाम हैं। हम स्पष्ट कारणों से इसे 0/1 मापक कह सकते हैं। इसे Z आधार माप भी कहा जाता है, क्योंकि विशेष संबंध के कारण 0 और 1 राज्यों में z नामक एक ऑपरेशन होता है। उस कहानी पर एक और बार।

अगले सबसे लोकप्रिय प्रकार का माप + और - के लिए एक है। मैं इसे +/- माप कहूंगा, लेकिन आप इसे एक्स आधार माप भी कह सकते हैं। यह पहले की तरह ही काम करता है, लेकिन सिर्फ 0 और 1. के बजाय + और - के लिए। यदि आप राज्य में एक क्वेट के साथ शुरू करते हैं और यह माप करते हैं, तो आपको परिणाम + मिल जाएगा। लेकिन अगर आप 0 से शुरू करते हैं और एक ही सवाल पूछते हैं, तो यह अनियमित रूप से चुनेगा।

हमारे पास अजीब तीर चीजों के लिए एक माप भी है। इसे Y आधार माप कहा जाता है। कोई भी वाई आधार माप पसंद नहीं करता है।

एक बिट सिर्फ एक बिट है, भले ही यह क्वांटम हो

गैर-क्वांटम वस्तुओं का मापन एक निष्क्रिय प्रक्रिया है। यह बताता है कि ऑब्जेक्ट क्या कर रहा है, लेकिन यह इसे किसी भी तरह से नहीं बदलता है। क्वांटम चीजों को मापना बहुत अलग है। क्वांटम माप केवल चर के बारे में हमारे ज्ञान को नहीं बदलते हैं। वे स्वयं चर बदलते हैं।

मान लीजिए कि आपके पास राज्य + में एक qubit है, और फिर यह पूछें कि क्या यह 0 या 1 है। जब यह आपको एक यादृच्छिक परिणाम देता है, तो यह आपको बंद नहीं कर रहा है। यह आपको कुछ बकवास नहीं बता रहा है क्योंकि आपने गलत प्रश्न पूछा है। एक बार जब यह आपको एक परिणाम देता है, तो यह इसके साथ चिपकेगा। यह मान है कि उत्तर को प्रतिबिंबित करने के लिए बदल जाएगा। यदि यह आपको 0 बताता है, तो यह हमेशा के लिए 0 होगा (या जब तक आप इसके साथ फिर से गड़बड़ न करें, कम से कम)। यह भूल जाएगा कि यह कभी + था।

इसका मतलब यह है कि एक qubit कभी केवल एक ही माप के लिए इसके परिणाम के बारे में सुनिश्चित हो सकता है। यदि यह निश्चित रूप से जानता है कि यह 0 या 1 है, तो यह पूरी तरह से अनिश्चित है कि यह + या - है, और पूरी तरह से अनिश्चित है कि यह it या is है या नहीं। ह्वेनबर्ग के अनिश्चितता के सिद्धांत द्वारा सीमित होने के लिए एक qubit के पास केवल निश्चित सीमा तक सीमित है।

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

खेल मैकेनिक

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

एक सामान्य कंप्यूटर पर इसे लागू करने के लिए, हम प्रत्येक जहाज के लिए दो बूलियन चर को परिभाषित कर सकते हैं। एक हमें बताएगा कि क्या जहाज बमों के लिए प्रतिरक्षा है, और दूसरे टॉरपीडो के लिए। फिर इन हमलों के दौरान जाँच की जा सकती है कि जहाज डूबता है या नहीं।

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

ऐसे जहाजों को बनाने से बचने का एक तरीका कोड की कुछ सरल पंक्तियों के साथ है। हालांकि यह वास्तव में हमारी शैली नहीं है। इसके बजाय, हम इसे क्वांटम यांत्रिकी के साथ ठीक करने जा रहे हैं!

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

हम इसे 0/1 माप के साथ बम हमले को जोड़कर कार्यान्वित करेंगे। यदि हमें परिणाम 1 मिलता है, तो हम कहते हैं कि जहाज डूब गया है। 0 के लिए हम यह मानते हैं कि जहाज बम हमलों के लिए प्रतिरक्षा है। टॉरपीडो के लिए हम इसके बजाय एक +/- माप करते हैं, - विनाश को नष्ट करने और + प्रतिरक्षा को लागू करने के साथ।

यह विधि एक जहाज के लिए दोनों प्रकार के हमले के लिए निश्चित रूप से प्रतिरक्षा करना असंभव बनाती है। अगर हमें पता चलता है कि दुश्मन का जहाज बमों से दूर है (यानी, इसकी स्थिति 0 है), तो हम जानते हैं कि यह टारपीडो (एक +/- माप के परिणाम) के बारे में पूरी तरह अनिश्चित होना चाहिए। चूंकि बम हमला निश्चित रूप से विफल होगा, इसलिए हमें अगले टारपीडो के साथ हमला करना चाहिए।

फिर यह पता चल सकता है कि टारपीडो हमला विफल हो जाता है (राज्य + +- माप के बाद + बन जाता है)। जहाज तय करेगा कि निश्चित रूप से उनके लिए प्रतिरक्षा है, और आगे कोई टारपीडो हमला विफल होगा। लेकिन सारी आशा नहीं खोई है। टॉरपीडो के बारे में निश्चित होने से यह बमों के बारे में अनिश्चित हो गया है। उनके साथ अगली बार हमला करना (0/1 माप करना) जीत का कारण बन सकता है।

यदि बम हमला सफल नहीं होता है, तो हम वापस टारपीडो पर जाते हैं, और इसी तरह। जब तक जहाज अंत में डूब नहीं जाता तब तक दोनों के बीच तालमेल बनाए रखने के लिए सबसे अच्छी रणनीति है।

हम दोनों हमलों के लिए उनकी प्रतिरक्षा के बारे में अनिश्चित होने के रूप में जहाजों को शुरू करेंगे। यह वाई आधार वाले राज्यों में से किसी एक में क्विट को इनिशियलाइज़ करके किया जा सकता है। चलो ↻ के लिए चलते हैं। यह वास्तव में एक भाग है जो हमें भाग 1 में मिला है, जिसका नाम u3 (0.5 * pi, 0,0) 0 है, इसलिए हम पहले से ही इसे बनाना जानते हैं।

अल्पकालिक qubits से निपटना

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

मान लीजिए कि एक जहाज पर बम से हमला होता है और वह बच जाता है। फिर अगले दौर में यह एक टारपीडो से टकरा जाता है।

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

यह हमारे लिए काम नहीं करेगा। Qubits मानव समय के इंतजार के आसपास नहीं बैठ सकते हैं। कम से कम वर्तमान तकनीक के साथ उन्हें दुर्घटनाग्रस्त होने और जलने के लिए कुछ सेकंड पर्याप्त समय से अधिक हैं।

हर बार एक हमले के बाद नई क्वांटम प्रक्रिया चलाने का विकल्प है। पहली नौकरी को job राज्य के साथ आरंभ किया जाएगा, ताकि परिणाम 0/1 माप (बम हमले) या +/- माप (टारपीडो हमले) दोनों के लिए यादृच्छिक होंगे। माप का परिणाम तब रिकॉर्ड किया जाता है और सामान्य कंप्यूटर पर मेमोरी में संग्रहीत किया जाता है। जब अगला हमला होता है, तो यह देखने के लिए एक और काम बनाया जाता है। इसे अंतिम माप के परिणाम के साथ आरंभ किया जाएगा, और इसलिए यह जारी है।

एक +/- माप करना

अब तक मैंने शब्दों का एक पूरा भार लिखा है, लेकिन कोड की एक भी पंक्ति नहीं। चलिए याद करते हैं कि QASM कोड में 0/1 माप कैसे लागू किया जाता है।

उपाय q [0] -> c [0];

सी की भूमिका [0] यहाँ फिर से आना महत्वपूर्ण है। यह माप प्रक्रिया का आउटपुट है। यह सामान्य बिट है जिस पर माप का परिणाम संग्रहीत किया जाता है। 0/1 माप के लिए परिणाम 0 या 1 है।

यह 0/1 माप के लिए सभी बहुत सीधा है। लेकिन यह +/- माप है जिसे हम अभी देख रहे हैं। हम उनमें से एक से कैसे जानकारी प्राप्त कर सकते हैं?

हम अभी भी परिणाम को सामान्य बिट c [0] में संग्रहीत करना चाहते हैं। चूँकि यह एक सामान्य सा है, इसलिए इसे विचित्र अवस्थाओं + और - का ज्ञान नहीं है। यह केवल सामान्य बाइनरी जानता है। इसलिए हम परिणाम की रिपोर्ट + के रूप में c [0] = 0, और - c [0] = 1 के रूप में करते हैं। तथ्य यह है कि ये 0/1 माप के परिणाम के समान दिखाई देंगे, कोई समस्या नहीं होगी। किसी भी कंप्यूटर प्रोग्राम की तरह, हमें पता होना चाहिए कि हमने क्या प्रोग्राम किया है, और इसलिए हमें पता होना चाहिए कि परिणामों की व्याख्या कैसे करें।

अब हम जानते हैं कि परिणामों को +/- माप से कैसे प्राप्त किया जाए। लेकिन हमें अभी तक यह पता नहीं चला है कि वास्तव में ऐसा कैसे किया जाता है। ऐसा इसलिए है क्योंकि हमें इसके बारे में डरपोक होने की जरूरत है। हमें उस प्रक्रिया को हैक करने की आवश्यकता है जो 0/1 माप करता है और इसे इसके बजाय +/- एक करता है।

हमारे हैक की कुंजी हैडामर्ड नामक एक ऑपरेशन है। क्यूएएसएम कोड में इसे एक क्वेट क्यू [0] पर लागू करना इस तरह दिखता है।

मुख्यालय [0];

ग्रिड लाइन नामक QASM फ़ाइल में इस लाइन को जोड़ने के लिए हम पायथन में जिस कमांड का उपयोग करते हैं

gridScript.h (क्यू [0])

हदामर्ड का प्रभाव एक्स आधार वाले और इसके विपरीत जेड आधार राज्यों को स्वैप करना है। यह स्फियर का एक घूर्णन है जो एक क्वैबिट स्थिति को 0 में + और + से 0. तक घुमाता है, इसी तरह, 1 को घुमाया जाता है - और इसके विपरीत।

इसका मतलब यह है कि कहानी हम हैमर्ड से पहले 0 और 1 के संदर्भ में एक qubit के बारे में बता सकते हैं, हमें उसके बाद + और - के साथ बताना होगा। और + और - की कोई भी कहानी 0 और 1 में से एक बन जाती है।

यह वही है जो हमें चाहिए। इसका अर्थ है कि एक क्वेट q [0] पर +/- माप निम्नलिखित QASM कोड द्वारा किया जा सकता है।

मुख्यालय [0]; उपाय q [0] -> c [0]; मुख्यालय [0];

यह देखने के लिए कि यह क्यों काम करता है, चलो कुछ उदाहरणों के माध्यम से चलते हैं। क्वेट q [0] प्रत्येक में नए सिरे से घोषित करना शुरू कर देगा, और इसलिए यह 0 के अपने डिफ़ॉल्ट प्रारंभिक मूल्य में होगा।

उदाहरण शून्य:

उपाय q [0] -> c [0];

राज्य में क्विट शुरू होता है 0. यह पूछा जाता है कि क्या यह 0 या 1 है और उत्तर c [0] बताता है। परिणाम हमेशा c [0] = 0 होगा।

उदाहरण एक:

XQ [0];
उपाय q [0] -> c [0];

क्वेट राज्य में 0 से शुरू होता है और फिर 1 पर घूम जाता है। फिर यह पूछा जाता है कि क्या यह 0 है या 1. यह हमेशा 1 उत्तर देता है।

उदाहरण +:

मुख्यालय [0];
उपाय q [0] -> c [0];

क्वेट राज्य में 0 से शुरू होता है और तुरंत + पर घूम जाता है। फिर यह पूछा जाता है कि इसका राज्य 0 है या 1. यह अनियमित रूप से एक या दूसरे को चुनता है, और इसका राज्य उत्तर के साथ अपडेट किया जाता है।

अब हमने कुछ तुच्छ उदाहरण दिए हैं, चलो कुछ और जटिल करते हैं।

उदाहरण ++:

मुख्यालय [0];
मुख्यालय [0]; उपाय q [0] -> c [0]; मुख्यालय [0];

अवस्था 0 में शुरू होती है और फिर + तक घूम जाती है। उसके बाद, दो समान तरीके हैं जो हम कहानी को जारी रख सकते हैं।

एक कहना है कि तीन अंतिम रेखाएं सामूहिक रूप से +/- माप बनाती हैं। वे प्रश्न पूछते हैं कि क्या यह + या - है। + के लिए वे परिणाम c [0] = 0 लौटाते हैं, और for - वे c [0] = 1 लौटाते हैं। चूंकि इस उदाहरण में क्वेट राज्य + के साथ माप में जाता है, इसलिए इसे हमेशा + के रूप में मापा जाता है। यह इसलिए इस राज्य में अभी भी माप से बाहर आता है।

अन्य कहानी के लिए हम एक-एक करके लाइनों के प्रभावों को देखते हैं। दूसरा हैडमार्ड पहले के प्रभाव को कम करता है, और इसलिए क्वेट को वापस राज्य में घुमाता है 0. यह पूछा जाता है कि क्या इसकी स्थिति 0 या 1 है, और इसलिए हमेशा जवाब देता है 0. आगे हैडमार्ड ने इसे फिर से घुमाया +।

दोनों ही कहानियाँ अवलोकनीय प्रभावों पर सहमत हैं। वे इस बात से सहमत हैं कि आउटपुट c [0] हमेशा 0 होगा, और वे इस बात से सहमत हैं कि अंत में क्वेट स्टेट + होगा। वे सिर्फ इस बात पर असहमत हैं कि यह कैसे हुआ। दोनों व्याख्याएँ समान रूप से मान्य हैं।

यदि आप कुछ शब्दजाल विकिपीडिया पर देखना चाहते हैं, तो ये क्वांटम यांत्रिकी के श्रोडिंगर और हाइजेनबर्ग चित्रों के उदाहरण हैं।

उदाहरण +1:

XQ [0];
मुख्यालय [0]; उपाय q [0] -> c [0]; मुख्यालय [0];

यहां एक और उदाहरण है, जिसके लिए हमारे पास दो समकक्ष कहानियां हैं। हम कह सकते हैं कि q [0] 0 के रूप में शुरू होता है और फिर 1 पर घुमाया जाता है। इसे 0/1 माप के माध्यम से जाने से पहले t0 को घुमाया जाता है। यह बेतरतीब ढंग से एक या दूसरे को तय करता है, आउटपुट c [0] = 0 या c [0] = 1 देता है और इसके अनुसार इसकी स्थिति अपडेट होती है। यदि यह 0 का फैसला करता है, तो अंतिम हैडमर्ड ने इसे + पर घुमाया। अन्यथा यह समाप्त हो जाएगा -।

वैकल्पिक रूप से हम कह सकते हैं कि 1 को घुमाए जाने के बाद, क्वेट + +- माप से होकर जाता है। यह इन दो विकल्पों के बीच बेतरतीब ढंग से निर्णय लेता है, जिससे आउटपुट c [0] = 0 for + और c [0] = 0 for - मिलता है। राज्य के अनुसार अद्यतन किया जाता है, या तो राज्य में समाप्त होता है + या -।

फिर, ये दोनों कहानियां समान रूप से मान्य हैं और सभी अवलोकन प्रभावों पर सहमत हैं। अगर हम तीन लाइनों के बारे में सोचना चाहते हैं

मुख्यालय [0]; उपाय q [0] -> c [0]; मुख्यालय [0];

एक +/- माप के रूप में, हम ऐसा करने के लिए स्वतंत्र हैं। यदि हम इसे एक हैडमर्ड के रूप में सोचना चाहते हैं तो एक हैडमर्ड द्वारा 0/1 माप के बाद, यह ठीक है।

हम आगे बढ़ने से पहले एक महत्वपूर्ण बात ध्यान दें। आईबीएम के एपीआई ने वर्तमान में इसे मापने के बाद हमें कुछ भी नहीं करने दिया। यह क्वांटम कंप्यूटरों के लिए एक सामान्य नियम नहीं है। आमतौर पर हम उम्मीद करते हैं कि जब तक हम चाहें, तब तक qubits की माप और हेरफेर करने में सक्षम होंगे। लेकिन हम इसे फिलहाल नहीं कर सकते।

इससे हमें कोई समस्या नहीं है। चूँकि खिलाड़ी किसी भी तरह से चुनाव करते हैं, इसलिए हम आसपास नहीं बैठ सकते हैं, हम पहले से ही प्रत्येक माप दौर के बाद पूरी तरह से राज्य को फिर से बनाना चाहते हैं। दूसरा हैडमर्ड प्रभावी रूप से अगली नौकरी में बदल जाएगा, जो राज्य के पुनर्जन्मित संस्करण पर काम करेगा।

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

त्रुटियों से निपटना

वर्तमान क्वांटम तकनीक सही नहीं है। क्वैब हमेशा ऐसा नहीं करते हैं जो उन्हें करना चाहिए। यदि आपकी qubit 0 है और आप 0/1 माप करते हैं, तो परिणाम हमेशा 0. हमेशा होना चाहिए। लेकिन वर्तमान क्वांटम उपकरणों के साथ, यह एक मौका होगा यह 1 होगा। यह हो सकता है क्योंकि एक्स ऑपरेशन में झपकी आ गई जबकि हम देख नहीं रहे थे। यह हो सकता है क्योंकि माप हमारे लिए झूठ बोल रहा है। इस तरह की घटनाएं दुर्लभ हैं, लेकिन वे होती हैं।

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

त्रुटियों से निपटने का दूसरा तरीका उनके प्रभावों को हटाने की कोशिश करना है। यदि कई क्वैबिट उपलब्ध थे, तो हम क्वांटम त्रुटि सुधार के साथ ऐसा कर सकते थे। दुर्भाग्य से, यह अभी भी कुछ साल दूर है।

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

नीरव मामले में, संभावित सभी 0%, 100% या 50% होंगे। एक परिणाम या तो असंभव है (जैसे कि अगर राज्य 0 है तो 1 प्राप्त करना), निश्चित (जैसे कि अगर राज्य + है तो) + या पूरी तरह से यादृच्छिक (जैसे कि 0 तब मिलता है जब राज्य + है)।

शोर इनको थोड़ा गड़बड़ कर देगा। जब हम 0 का 0/1 माप करते हैं, तो हम यह पा सकते हैं कि परिणाम 0 केवल 98% समय पर होता है, जिसमें 2% 1 के बजाय 1 होते हैं। इसके लिए सही करने के लिए हम कुछ मनमाना काम करेंगे। हम तय करेंगे कि 5% से कम संभावना वाले कुछ भी कभी नहीं होना चाहिए। 95% से अधिक संभावना वाली कोई भी चीज़ निश्चित होनी चाहिए।

यह सब एक साथ डालें

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

यदि ऐसा कुछ है जो आपको लगता है कि अधिक स्पष्टीकरण की आवश्यकता है, तो मुझे बताने के लिए स्वतंत्र महसूस करें।