क्वांटम कम्प्यूटेशन का अनुकरण करते समय उलझनों का ट्रैक कैसे रखें?

Question

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

मुझे पता है $n$ qubits a के साथ स्टोर किया जा सकता है $2^n$तत्व जटिल सरणी। यह भी एक$n$ क्वेट गेट एक है $2^n \times 2^n$2 डी सरणी। तो, निम्नलिखित मेरी शंकाएँ हैं (ज्यादातर उलझाव से संबंधित):

1. मुझे फाटकों के दसियों उत्पाद को खोजने की आवश्यकता कब है (जैसे $I \otimes H \otimes I$, के लिए $3$qubit system)? क्या ऑर्डर के टेंसर उत्पाद की गणना करना हमेशा आवश्यक होता है$2^n \times 2^n$, भले ही क्वाइल उलझी न हों?

2. केवल ए के साथ $2^n$तत्व सरणी (जो मैं गुणांक को संग्रहीत करता हूं), क्या मैं वास्तव में किसी भी तरह से गणना कर सकता हूं कि कौन सी श्रेणियां उलझी हुई हैं? या क्या मुझे अपनी उलझने वाली जानकारी को संग्रहीत करने के लिए एक और डेटा संरचना बनाने की आवश्यकता है$n$ qubits (किन क्वैबों के बारे में उलझा हुआ है)?

3. क्या मेरा दूसरा प्रश्न वास्तव में प्रासंगिक है? क्या मुझे उलझी जानकारी पर नज़र रखने की ज़रूरत है? मेरा मतलब है, मुझे नहीं पता कि गुणांक के साथ फाटकों को गुणा करना पर्याप्त है (भले ही सिस्टम उलझ गया हो)। शायद यह केवल माप के समय पर प्रासंगिक है।

Comments

पर निर्भर करता है $n$उलझाव पैटर्न का ट्रैक रखने के लिए अनुकूलन समय से पहले है या नहीं। यदि आपके पास अभी 3 क्वैबिट्स हैं, तो आप उस प्रयास को लगाकर अधिक लाभ नहीं उठा रहे हैं, इसलिए यह "समय से पहले अनुकूलन" होगा। तो अपने आप से पूछें, वास्तव में आपको कितना स्केलेबल होना चाहिए।

— हुसैन

@ मिधुनएक्सडीए "मुझे पता है कि शारीरिक रूप से क्या हो रहा है, लेकिन मैं इसे गणितीय रूप में परिवर्तित करने में सक्षम नहीं हूं"। जहां तक ​​मुझे जानकारी है, कई भौतिक प्रक्रियाएं हैं जो क्वांटम गणना की ओर ले जाती हैं। मुझे लगता है कि यह एक अच्छा विचार हो सकता है अगर आप ठीक (, या उन सभी को अगर आपको लगता है कि अभी भी प्रश्न के दायरे में होगा) उन भौतिक प्रक्रियाओं जो आप का अनुकरण करना चाहते हैं में से एक का वर्णन। मुझे लगता है कि इसे निर्दिष्ट करने से प्रश्न स्पष्ट और उत्तर देने में आसान हो जाता है।

— छिपकली

कृपया इसे कई प्रश्नों में विभाजित करें - मैं कम से कम तीन अलग-अलग लोगों को देखता हूं।

— हीथ

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

— DaftWullie

@ हीथ मैं दृढ़ता से मध्यस्थों को अत्यधिक मामलों में छोड़कर अपने आप से सवाल न करने की सलाह देता हूं (पढ़ें: blatantly ऑफ-टॉपिक या स्पैम)। यह सवाल है, हालांकि थोड़ा चौड़ा एक पोस्ट में यथोचित उत्तर दिया जा सकता है। एफडब्ल्यूआईडब्ल्यू मूल रूप से दो प्रश्न यहां हैं: 1) गेट्स के टेंसर उत्पादों की गणना कब करें? 2) ऐसा करते समय उलझाव के प्रभाव को कैसे ध्यान में रखा जाए?

— संचेतन दत्ता

Answer 1

यह निश्चित रूप से हमेशा पूर्ण गणना करने के लिए पर्याप्त है $2^n\times 2^n$ एकात्मक मैट्रिक्स, और फिर इसे लागू करें $2^n$-एंट्री स्टेट वेक्टर। यदि यह मान लें कि आप क्या करने के लिए चुनते हैं क्या होगा, तो इस सब आप सभी उलझाव जानकारी है कि वेक्टर में निहित है के रूप में क्या करना है। यह देखने के लिए एक त्वरित और आसान तरीका है कि क्या किसी विशेष qubit में उलझी हुई है, अन्य सभी qubits पर आपके (शुद्ध) स्टेट वेक्टर का आंशिक ट्रेस लेना है। यदि परिणामी मैट्रिक्स रैंक 1 है, तो वह एक अलग स्थिति में है, अन्यथा यह उलझा हुआ है।

मुझे लगता है कि आपके प्रश्न का बिंदु वास्तव में है "इस विशाल कम्प्यूटेशनल लागत से कैसे बचा जा सकता है?"। सामान्य तौर पर, यह नहीं हो सकता है - यदि आप क्वांटम कंप्यूटर की पूरी शक्ति का उपयोग कर रहे हैं, तो आपको हमेशा इसकी आवश्यकता होगी$2^n$-एंट्री स्टेट वेक्टर। हालांकि, विभिन्न चालें हैं जो कम्प्यूटेशनल लागत को कम करती हैं, जैसे कि उलझाव का ट्रैक रखकर इतने बड़े राज्य वेक्टर की आवश्यकता में देरी।

दक्षता में सुधार

ऊपर के भोले कार्यान्वयन की तुलना में आप जो सबसे बड़ी बचत कर सकते हैं वह है इससे बचना $2^n\times 2^n$एकात्मक मैट्रिसेस। उदाहरण के लिए, यदि आप केवल 1- या 2-qubit फाटक का उपयोग कर रहे हैं, तो बस मैट्रिस की विरलता का उपयोग करने का मतलब है कि आपको केवल आवश्यकता है$O(2^n)$ के बजाय भंडारण $O(2^{2n})$।

फिर अन्य रणनीति हैं जिन्हें आप नियोजित कर सकते हैं। उदाहरण के लिए, कल्पना करें कि आप दो-क्विट एकात्मक गेट को लागू करना चाहते हैं$U$ qubits पर $i$ तथा $j$। आप अपने राज्य वेक्टर से 4 तत्वों के सेट ले सकते हैं ($|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$ तय हो गया $x\in\{0,1\}^{n-2}$ सब अलग-अलग लेकर $y\in\{0,1\}^2$) और सिर्फ आवेदन करना $4\times 4$ अमली $U$उस 4-तत्व वेक्टर पर। हर के लिए यह दोहरा$x$ वापस होगा $U$ मूल राज्य वेक्टर पर अधिनियमित।

मुझे लगता है कि ऐसी अन्य रणनीतियाँ हैं जिनके साथ कोई आ सकता है। मूल प्रश्न से खुद को सुझाने वाला उलझाव ट्रैकिंग था। यह एक संगणना की शुरुआत में स्मृति और गति में सुधार देता है, लेकिन अंत में समतुल्य होने के कारण समाप्त होता है क्योंकि (संभवतः) क्वांटम कंप्यूटर में सब कुछ उलझ जाएगा।

Entanglement Tracking

मान लेते हैं कि आपके संगणना के सेट पर केवल एकात्मक विकास और माप शामिल हैं$n$ qubits, यानी कोई डिकॉयर्सेंस, प्रोबेबिलिस्टिक मैप्स आदि नहीं हैं। चलिए आगे मानते हैं कि आप पूरी तरह से अलग राज्य से शुरू करते हैं जैसे कि $|0\rangle^{\otimes n}$। इस बिंदु पर, प्रत्येक qubit वियोज्य है, और यह रखने के लिए पर्याप्त है$n$विभिन्न रजिस्टरों, प्रत्येक एक अलग करने योग्य राज्य की स्थिति को व्यक्त करते हैं। अगर आपका पहला गेट सिर्फ सिंगल-क्वाबिट ऑपरेशन है$U$ पर $i$, तो आप बस क्वेट पर संग्रहीत स्थिति को अपडेट करें $i$ जैसा $|\psi_i\rangle\mapsto U|\psi_i\rangle$, और आपको कुछ और छूने की जरूरत नहीं है।

अगर आप टू-क्विट गेट करना चाहते हैं $V$ बटेर के बीच $i$ तथा $j$, कहते हैं, तो आपको दोनों साइटों पर राज्यों को जोड़ना होगा। इसलिए, आप दो आयामों को प्रत्येक आयाम 2 को 4 के एक रजिस्टर के साथ प्रतिस्थापित करते हैं, जिसमें राज्य है$V|\psi_i\rangle|\psi_j\rangle$। समस्या यह है कि अब आप इस स्थिति को फिर से विभाजित नहीं कर सकते हैं, इसलिए आपको उन दो बटेरों को एक रजिस्टर में हमेशा के लिए रखना होगा। बेशक, यदि आपके पास कभी भी 1-qubit गेट है$U$ qubit पर लागू करने के लिए $i$, अब आपको आवेदन करना होगा $|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$। फिर, अगली बार जब आप के बीच 2-क्विट गेट चाहते हैं,$j$ तथा $k$, आपको रिक्त स्थान संयोजित करना होगा $(i,j)$ तथा $k$। वे रिक्त स्थान बढ़ते रहेंगे, लेकिन यदि कोई गेट सिर्फ एक स्थान पर स्थानीयकृत है, तो आपको इसे वहां लागू करना होगा (उपयोग करके$\mathbb{I}$ ऑपरेटरों ने इसे बाकी की दुकानों पर रखा है), और आपको अन्य स्थानों के लिए कुछ भी करने की ज़रूरत नहीं है।

यदि आप इस तरह की चीजें कर रहे हैं, तो आपके पास (कम से कम आपके एल्गोरिदम के पहले कुछ चरणों के लिए) एक भी नहीं होगा $2^n$तत्व रजिस्टर। आपको अलग-अलग रजिस्टरों का एक गुच्छा रखना होगा, और अलग-अलग ऐरे में किस रजिस्टर से क्वाइब का वर्णन किया जाता है, इस पर नज़र रखें। हर बार जब आप कुछ क्वाइबेट्स के रिक्त स्थान को जोड़ते हैं, तो आप उस अतिरिक्त सरणी को अपडेट करेंगे।

यहाँ कुछ बहुत क्रूड छद्म कोड है जो मेरा अर्थ बताने में मदद कर सकते हैं:

#initialise variables
entangled_blocks={{1},{2},{3},...,{n}}
quantum_states={{1,0},{1,0},...,{1,0}}

#apply action of each gate
for each gate
   for each gate_target
       target_block=entangled_blocks entry containing gate_target
   next gate_target
   if all target_blocks equal then
      apply gate on target_block (pad with identity on other qubits)
   else
      new_entangled_block=union(target_blocks)
      new_state_vec=tensor_product(quantum_states for each target block)
      apply gate on new_state_vec (pad with identity on other qubits)
      replace all target_blocks in entangled_blocks with new_entangled_block
      replace all quantum_states(all target blocks) with new_state_vec
   end if
next gate

अन्य विकल्प

(किसी भी तरह से नहीं)

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

Comments

मैं जो हासिल करने की कोशिश कर रहा हूं वह निश्चित तौर पर दक्षता है। इसके अलावा, मैं यह जानना चाहता हूं कि ये सभी प्रक्रियाएं कैसे काम करती हैं (cus I am a noobie)। तो, एक व्यावहारिक में, बेहतर विकल्प सिर्फ एक ही सरणी (रिकॉर्ड) में सभी क्वैबिटर्स गुणांक को एक साथ जमा करना है, है ना? जवाब देने के लिए शुक्रिया।

— मिधुन XDA

@DaftWullie आपका पहला वाक्य यह धारणा देता है कि सामान्य रूप से इसे पूर्ण रूप से संग्रहीत करने की आवश्यकता होगी $2^n\times 2^n$ एकात्मक, बल्कि केवल $2^n$वेक्टर।

— नोर्बर्ट शुच

@MidhunXDA दक्षता के मामले में, सब कुछ अनिवार्य रूप से समतुल्य है क्योंकि एक क्वांटम कंप्यूटर अंततः सब कुछ उलझा हुआ होगा। क्या चल रहा है, यह जानने के लिए, आप शायद राज्य वेक्टर के अनुरूप एकल सरणी के साथ शुरू कर रहे हैं। लेकिन, उलझी हुई ट्रैकिंग का उपयोग करके आप कुछ गति और स्मृति सुधार प्राप्त कर सकते हैं, जो थोड़ा अधिक सिमुलेशन सक्षम करना चाहिए।

— DaftWullie

@NorbertSchuch मैंने कहा कि ऐसा करना "पर्याप्त" था, जो सच है। मैंने इससे बचने के बारे में कुछ और विवरण जोड़ा है। आप शायद अन्य, बेहतर रणनीति के बारे में जानते हैं।

— DaftWullie