क्वांटम कंप्यूटिंग और AIमध्यमपाठ 3066 मिनट का पाठ

एक छोटे क्वांटम कंप्यूटर का सिम्युलेशन करना

क्वांटम स्टेट एम्प्लीट्यूड (amplitudes) का एक वेक्टर होती है, और गेट्स मैट्रिक्स होते हैं। numpy में Hadamard, X और CNOT बनाएं, एक Bell स्टेट बनाएं, और देखें कि n क्यूबिट्स के लिए 2ⁿ संख्याओं की ज़रूरत क्यों होती है।

✦ ट्यूटर से पूछें🧪 लैब · 30 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

एक छोटे क्वांटम कंप्यूटर का सिम्युलेशन करना

क्वांटम स्टेट एम्प्लीट्यूड (amplitudes) का एक वेक्टर होती है, और गेट्स मैट्रिक्स होते हैं। numpy में Hadamard, X और CNOT बनाएं, एक Bell स्टेट बनाएं, और देखें कि n क्यूबिट्स के लिए…

1/4
आसान शब्दों में
कोई रेसिपी सामग्री को एक-एक कदम करके बदलती है: काटना, मिलाना, पकाना। एक क्वांटम सर्किट संख्याओं की सूची को एक-एक कदम करके बदलता है। हर कदम एक गेट होता है, और हर गेट संख्याओं की एक छोटी टेबल होता है जिसे मैट्रिक्स कहते हैं। सूची को टेबल से गुणा करें, और आपको अगली सूची मिल जाती है। एक सिम्युलेटर बस यही करता है।
एक क्लासिकल कंप्यूटर एक छोटे क्वांटम कंप्यूटर का बिल्कुल सटीक सिम्युलेशन कर सकता है। हम स्टेट वेक्टर (state vector) को स्टोर करते हैं, जो सभी एम्प्लीट्यूड की सूची है, और हर गेट को मैट्रिक्स गुणा (matrix multiplication) के रूप में लागू करते हैं। असली हार्डवेयर पर चलाने से पहले शोधकर्ता अपने विचारों को इसी तरह परखते हैं।

तीन गेट्स

गेटकिस पर काम करता हैयह क्या करता हैमैट्रिक्स
X (NOT)1 क्यूबिट|0⟩ और |1⟩ को आपस में बदल देता है, क्लासिकल NOT की तरह[[0, 1], [1, 0]]
H (Hadamard)1 क्यूबिट|0⟩ → (|0⟩ + |1⟩)/√2 और |1⟩ → (|0⟩ − |1⟩)/√2[[1, 1], [1, −1]] / √2
CNOT2 क्यूबिट्सयदि पहला (कंट्रोल) क्यूबिट 1 है, तो दूसरे (टारगेट) क्यूबिट को उलट देता है4 × 4, 10 और 11 के एम्प्लीट्यूड को आपस में बदल देता है

दो क्यूबिट्स: क्रम और क्रोनेकर गुणनफल (Kronecker product)

दो क्यूबिट्स के लिए हम एम्प्लीट्यूड को 00, 01, 10, 11 के क्रम में लिखते हैं। इस ट्रैक में बायां बिट क्यूबिट 0 है और दायां बिट क्यूबिट 1 है। एक क्यूबिट पर सिंगल-क्यूबिट गेट लगाने और दूसरे को वैसे ही छोड़ देने के लिए, हम इसे Kronecker product (np.kron) का उपयोग करके आइडेंटिटी मैट्रिक्स I के साथ मिलाते हैं। उदाहरण के लिए, np.kron(H, I) क्यूबिट 0 पर H लागू करता है और क्यूबिट 1 को वैसा ही छोड़ देता है।
नोट
अलग-अलग टूल्स क्यूबिट्स को अलग क्रम में रखते हैं। कुछ क्यूबिट 0 को दाईं ओर रखते हैं। भौतिकी वही रहती है, लेकिन आपके वेक्टर्स उल्टे दिखेंगे। हमेशा जांच लें कि कोई टूल किस नियम का उपयोग करता है।

एक Bell स्टेट बनाएं

  1. 1

    शुरुआत

    दोनों क्यूबिट्स |0⟩ में: वेक्टर [1, 0, 0, 0]।
  2. 2

    क्यूबिट 0 पर Hadamard

    अब (|00⟩ + |10⟩)/√2।
  3. 3

    CNOT, कंट्रोल 0, टारगेट 1

    |10⟩ वाला हिस्सा |11⟩ बन जाता है। परिणाम: (|00⟩ + |11⟩)/√2।
Python: a Bell state from matricespython
import numpy as np

I = np.eye(2)
H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
CNOT = np.array([[1, 0, 0, 0],
                 [0, 1, 0, 0],
                 [0, 0, 0, 1],
                 [0, 0, 1, 0]])

state = np.array([1.0, 0, 0, 0])      # |00>
state = np.kron(H, I) @ state          # H on qubit 0
state = CNOT @ state                   # entangle
for label, amp in zip(["00", "01", "10", "11"], state):
    print(label, round(float(amp), 3), "prob", round(float(amp) ** 2, 3))

बड़े सिम्युलेशन कठिन क्यों हैं

एक क्यूबिट के लिए 2 एम्प्लीट्यूड की ज़रूरत होती है। दो के लिए 4। हर अतिरिक्त क्यूबिट सूची को दोगुना कर देता है। n क्यूबिट्स के लिए आपको 2ⁿ संख्याओं की ज़रूरत होती है, और हर गेट उनमें से कई को बदलता है। यह कितनी तेज़ी से बढ़ता है, यह देखने के लिए इसे चलाएं:
Python: memory for a full state vectorpython
# Each amplitude stored as a complex number takes 16 bytes (complex128 in numpy).
for n in [10, 20, 30, 40, 50]:
    amplitudes = 2 ** n
    gigabytes = amplitudes * 16 / 1e9
    print(f"{n:2d} qubits: {amplitudes:>20,d} amplitudes, about {gigabytes:,.3f} GB")
लगभग 30 क्यूबिट्स के लिए ही लगभग 17 GB की ज़रूरत होती है, जो कि ज़्यादातर लैपटॉप में खाली जगह से भी अधिक है। 50 क्यूबिट्स पर पूरे वेक्टर को लाखों गीगाबाइट की आवश्यकता होगी। चतुर तरीके कुछ विशेष सर्किट्स का अधिक क्यूबिट्स के साथ सिम्युलेशन कर सकते हैं, लेकिन सामान्य सर्किट्स के लिए यह दोगुना होना एक वास्तविक दीवार बन जाता है। यह दीवार एक कारण है कि लोग सोचते हैं कि क्वांटम कंप्यूटर वे काम कर सकते हैं जो क्लासिकल कंप्यूटर नहीं कर सकते।
सावधान रहें
ये 2ⁿ एम्प्लीट्यूड 2ⁿ ऐसे उत्तर नहीं हैं जिन्हें आप पढ़ सकते हैं। n क्यूबिट्स को मापने पर भी केवल n बिट्स ही मिलते हैं। बड़ी स्टेट केवल तभी उपयोगी होती है जब कोई एल्गोरिदम एम्प्लीट्यूड में ऐसा इंटरफेरेंस (हस्तक्षेप) पैदा करे जिससे उपयोगी उत्तर मिलने की संभावना बढ़ जाए।
इसे आज़माएं। Bell स्टेट कोड में, Hadamard से पहले np.kron(I, X) (क्यूबिट 1 पर X) जोड़ें। अब कौन से दो परिणाम दिखाई देते हैं?

और देखें और पढ़ें

लैब

एक numpy सिम्युलेटर जो गेट मैट्रिक्स से एक Bell स्टेट और दूसरी एंटैंगल्ड स्टेट बनाता है, और उनकी प्रायिकताएं प्रिंट करता है।

~30 min

समस्या

इसे ब्राउज़र में, या Python 3 और numpy के साथ चलाएं। क्यूबिट 0 बायां बिट है।

  1. start पर क्यूबिट 0 पर H और फिर CNOT लागू करके bell को (|00⟩ + |11⟩)/√2 के बराबर बनाएं। मैट्रिक्स का उपयोग करें, हाथ से टाइप किए गए उत्तरों का नहीं।
  2. फिर से start से शुरू करके, other को (|01⟩ + |10⟩)/√2 के बराबर बनाएं। संकेत: पहले एक क्यूबिट पर X लगाएं।
  3. show के साथ दोनों स्टेट्स की प्रायिकताएं प्रिंट करें।
  4. एक वाक्य लिखें: 3-क्यूबिट वर्शन के लिए कितने एम्प्लीट्यूड की आवश्यकता होगी?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1सिम्युलेटर को 3 क्यूबिट्स तक बढ़ाएं और (|000⟩ + |111⟩)/√2 बनाएं। आपको किन गेट्स की आवश्यकता है?दिखाएं

np.kron(np.kron(H, I), I) के साथ क्यूबिट 0 पर H लागू करें। फिर np.kron(CNOT, I) के साथ क्यूबिट 0 से क्यूबिट 1 पर CNOT लागू करें, और np.kron(I, CNOT) के साथ क्यूबिट 1 से क्यूबिट 2 पर CNOT लागू करें। स्टेट वेक्टर में 8 एम्प्लीट्यूड होते हैं, और केवल 000 और 111 गैर-शून्य होते हैं। इसे अक्सर GHZ स्टेट कहा जाता है।

Q2हमारा सिम्युलेटर पूरे 4 × 4 या 8 × 8 मैट्रिक्स बनाता है। गंभीर सिम्युलेटर हर गेट के लिए 2ⁿ × 2ⁿ मैट्रिक्स बनाने से क्यों बचते हैं?दिखाएं

n क्यूबिट्स के एक पूरे मैट्रिक्स में 2ⁿ × 2ⁿ प्रविष्टियाँ (entries) होती हैं, जो खुद स्टेट वेक्टर से बहुत अधिक हैं। चूंकि प्रत्येक गेट केवल एक या दो क्यूबिट्स को छूता है, इसलिए एक सिम्युलेटर बड़ा मैट्रिक्स बनाए बिना ही स्टेट वेक्टर को सीधे, जोड़े दर जोड़े या एम्प्लीट्यूड के छोटे समूहों में अपडेट कर सकता है। फिर आवश्यक मेमोरी लगभग स्टेट वेक्टर के आकार जितनी होती है, जो अभी भी 2ⁿ ही है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

गेट्स मैट्रिक्स क्यों होते हैं?

क्वांटम मैकेनिक्स कहती है कि किसी बंद सिस्टम में (बिना मापे) आप जो बदलाव कर सकते हैं वे लीनियर होते हैं और कुल प्रायिकता (probability) को 1 के बराबर रखते हैं। लीनियर मैप मैट्रिक्स होते हैं, और "प्रायिकता 1 रखने" के नियम का मतलब है कि मैट्रिक्स यूनिटरी (unitary) हैं। X, H और CNOT सभी यूनिटरी हैं।

क्या मापना (measurement) भी एक मैट्रिक्स है?

उस तरह से नहीं। मापन कोई यूनिटरी गेट नहीं है: यह Born नियम के साथ एक रैंडम परिणाम चुनता है और फिर स्टेट उस परिणाम से मेल खाने के लिए बदल (jump कर) जाती है। हमारे सिम्युलेटर में हम प्रायिकताओं में से सैंपलिंग करके ऐसा करते हैं।

क्या असली क्वांटम प्रोग्राम इसी तरह लिखे जाते हैं?

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

यदि सिम्युलेशन इतना कठिन है, तो हम कैसे जांचते हैं कि बड़े क्वांटम कंप्यूटर सही हैं?

यह एक वास्तविक चुनौती है। शोधकर्ता उन छोटे हिस्सों की जांच करते हैं जिनका सिम्युलेशन किया जा सकता है, ऐसे विशेष सर्किट्स का उपयोग करते हैं जिनके उत्तर ज्ञात हैं, और ऐसी समस्याओं का उपयोग करते हैं जहाँ प्रस्तावित उत्तर को सत्यापित करना आसान होता है, जैसे कि यह जांचना कि दो संख्याओं को गुणा करने पर तीसरी संख्या मिलती है या नहीं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें