समीकरणों के रैखिक प्रणालियों के लिए क्वांटम एल्गोरिदम (HHL09): चरण 2 - प्रारंभिक राज्यों की तैयारी

^{यह समीकरणों के रैखिक प्रणालियों (HHL09) के लिए क्वांटम एल्गोरिदम की एक निरंतरता है : चरण 2 - क्या है $|\Psi_0\rangle$ ?}

कागज में: समीकरणों के रैखिक प्रणालियों के लिए क्वांटम एल्गोरिदम (हैरो, हासिडिम और लॉयड, 2009) , एल्गोरिथ्म के वास्तविक कार्यान्वयन का विवरण नहीं दिया गया है। कैसे बिल्कुल राज्यों $|\Psi_0\rangle$ तथा $|b\rangle$ बनाए जाते हैं, एक " ब्लैक-बॉक्स " की तरह होता है (पेज 2-3 देखें)।

| Ψ_{0} ⟩ = \sqrt{\frac{2}{T}} \sum_{τ = 0}^{T - 1} \sin \frac{π (τ + \frac{1}{2})}{T} | τ ⟩

$|\Psi_0\rangle = \sqrt{\frac{2}{T}}\sum_{\tau = 0}^{T-1}\sin \frac{\pi (\tau+\frac{1}{2})}{T}|\tau\rangle$

तथा

| b ⟩ = \sum_{1}^{N} b_{i} | i ⟩

$|b\rangle = \sum_{1}^{N}b_i|i\rangle$

कहाँ पे $|\Psi_0\rangle$ घड़ी रजिस्टर की प्रारंभिक स्थिति है और $|b\rangle$ इनपुट रजिस्टर की प्रारंभिक अवस्था है।

(कहो) मैं आईबीएम पर उनके एल्गोरिथ्म को अंजाम देना चाहता हूं $16$ -क्वेट क्वांटम कंप्यूटर। और मैं एक निश्चित समीकरण को हल करना चाहता हूं $\mathbf{Ax=b}$ कहाँ पे $\mathbf{A}$ एक है $4\times 4$ असली प्रविष्टियों के साथ हर्मिटियन मैट्रिक्स और $\mathbf{b}$ एक है $4\times 1$ वास्तविक प्रविष्टियों के साथ कॉलम वेक्टर।

आइए एक उदाहरण लेते हैं:

ए = [\begin{matrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{matrix}]

$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{bmatrix}$

तथा

ख = [\begin{matrix} 1 \\ 2 \\ 3 \\ 4 \end{matrix}]

$\mathbf{b}=\begin{bmatrix} 1 \\ 2 \\ 3 \\ 4 \end{bmatrix}$

के आयामों को देखते हुए $\mathbf{A}$ तथा $\mathbf{b}$ , हमें चाहिए $\lceil{\log_2 4\rceil}=2$ इनपुट रजिस्टर और एक अन्य के लिए qubits $6$ क्लॉक रजिस्टर के लिए क्वैबिट्स मानते हैं कि हम चाहते हैं कि आइजनवेल्यूज़ का प्रतिनिधित्व किया जाए $90\%$ सटीकता और अप करने के लिए $3$ eigenvalues के लिए -bit परिशुद्धता (यह पहले यहां चर्चा की गई है )। तो कुल $2+6+1=9$ इस उद्देश्य (अतिरिक्त) के लिए qubits की आवश्यकता होगी $1$ qubit ancilla है)।

प्रशन:

इस जानकारी का उपयोग करना, क्या शुरुआती राज्यों को बनाना संभव है $|\Psi_0\rangle$ तथा $|b\rangle$ आईबीएम पर $16$ वर्जन संस्करण?
अगर आपको लगता है $4\times 4$ आईबीएम क्वांटम कंप्यूटरों पर लागू होने के लिए बहुत बड़ा है आप एक के लिए प्रारंभिक राज्य की तैयारी का एक उदाहरण भी दिखा सकते हैं $2\times 2$ हर्मिटियन मैट्रिक्स $\mathbf{A}$ (या सिर्फ ऐसे उदाहरण के लिए एक संदर्भ दें)।

मैं बस इस बारे में एक सामान्य विचार प्राप्त करना चाहता हूं कि क्या यह आईबीएम 16-क्वांट क्वांटम कंप्यूटर पर किया जा सकता है (अर्थात यह संभव है), और इसके लिए कौन सा गेट आवश्यक होगा। यदि आईबीएम 16-क्वांटम क्वांटम कंप्यूटर नहीं है, तो प्रारंभिक स्थिति की तैयारी को फिर से तैयार करने के लिए क्यूओसिट सिम्युलेटर का उपयोग किया जा सकता है $|\Psi_0\rangle$ तथा $|b\rangle$ HHL एल्गोरिथ्म में? क्या इस बारे में कोई और बेहतर विकल्प है?

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

जहां तक मुझे पता है आईबीएम एचएचएल नहीं कर सकता क्योंकि इसमें अलग-अलग समय के सुपरपोजिशन में चीजें करना शामिल है, लेकिन अगर मैं गलत हूं तो मुझे आश्चर्य नहीं होगा। @James Woottoon बेहतर जवाब जान सकता है।

— user1271772

@ user1271772 मैंने भी ऐसा सोचा था, लेकिन मैं थोड़ा उलझन में हूं क्योंकि किसी ने मुझे चैट में बताया कि उन्होंने इसके लिए HHH का अनुकरण किया

4 \times 4

$4\times 4$ निम्नलिखित इस , आईबीएम पर।

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

अच्छी तरह से, शायद यूडोंग काओ के पेपर का अंजीर 4 (आप जिसे लिंक करते हैं) आप सभी की जरूरत है।

— user1271772

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

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

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

— user1271772

जवाबों:

प्रारंभिक अवस्थाएँ बनाना संभव नहीं है $\left| \Psi_0\right>$ तथा $\left|b\right>$ IBM 16 क्वैबिट संस्करण पर। दूसरी ओर, उन्हें मनमाने ढंग से कम त्रुटि ^{1 के} साथ अनुमानित करना संभव है क्योंकि आईबीएम चिप्स द्वारा लागू किए गए फाटक इस संभावना की पेशकश करते हैं।

यहां आप 2 अलग-अलग क्वांटम राज्यों की मांग करते हैं:

$\left| b \right>$ प्रतिबंधित नहीं है। राज्य $\left| b \right>$ के वेक्टर द्वारा दर्शाया गया है $N$ जटिल संख्या जो कुछ भी हो सकती है (जब तक कि वेक्टर में एकात्मक मानदंड है)।
$\left| \Psi_0 \right>$ के विशेष मामले के रूप में देखा जा सकता है $\left| b \right>$ , जहां गुणांक है $b_i$ अधिक विवश हैं।

इस विश्लेषण के साथ, कोई भी विधि जो बनाने के लिए उपयोग की जा सकती है $\left|b\right>$ बनाने के लिए भी इस्तेमाल किया जा सकता है $\left| \Psi_0 \right>$ । दूसरी ओर, जैसा कि $\left| \Psi_0 \right>$ अधिक विवश है, हम उम्मीद कर सकते हैं कि उत्पादन करने के लिए अधिक कुशल एल्गोरिदम मौजूद हैं $\left| \Psi_0 \right>$ ।

के लिए उपयोगी $\left|b\right>$ तथा $\left|\Psi_0\right>$ : क्वांटम लॉजिक सर्किट (शेंडे, बैल और मार्कोव, 2006) के संश्लेषण के आधार पर , QISKit पायथन एसडीके एक मनमाना क्वांटम राज्य को आरंभ करने के लिए एक सामान्य विधि को लागू करता है।

के लिए उपयोगी $\left|\Psi_0\right>$ : सुपरपोजिशन बनाना जो कुशलता से पूर्ण होने योग्य संभाव्यता वितरण के अनुरूप हैं (ग्रोवर और रूडोल्फ, 2002) एक स्थिति को शुरू करने के लिए जल्दी से एक एल्गोरिथ्म प्रस्तुत करता है जिसका आयाम कुछ बाधाओं का सम्मान करते हुए संभाव्यता वितरण का प्रतिनिधित्व करता है। इन बाधाओं का सम्मान किया जाता है $\left|\Psi_0\right>$ समीकरणों के रैखिक प्रणालियों (हैरो, हासिमिम और लॉयड, 2009) को हल करने के लिए क्वांटम एल्गोरिथम के अनुसार , पृष्ठ 5 की अंतिम पंक्ति।

कियोस्किट पर कार्यान्वयन के लिए, यहां दिए गए क्वांटम राज्य को आरम्भ करने का एक नमूना है:

import qiskit

statevector_backend = qiskit.get_backend('local_statevector_simulator')

###############################################################
# Make a quantum program for state initialization.
###############################################################
qubit_number = 5
Q_SPECS = {
    "name": "StatePreparation",
    "circuits": [
        {
            "name": "initializerCirc",
            "quantum_registers": [{
                "name": "qr",
                "size": qubit_number
            }],
            "classical_registers": [{
                "name": "cr",
                "size": qubit_number
            }]},
    ],
}
Q_program = qiskit.QuantumProgram(specs=Q_SPECS)

## State preparation
import numpy as np
from qiskit.extensions.quantum_initializer import _initializer

def psi_0_coefficients(qubit_number: int):
    T = 2**qubit_number
    tau = np.arange(T)
    return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1/2) / T)

def get_coeffs(qubit_number: int):
    # Can be changed to anything, the initialize function will take
    # care of the initialisation.
    return np.ones((2**qubit_number,)) / np.sqrt(2**qubit_number)
    #return psi_0_coefficients(qubit_number)

circuit_prep = Q_program.get_circuit("initializerCirc")
qr = Q_program.get_quantum_register("qr")
cr = Q_program.get_classical_register('cr')
coeffs = get_coeffs(qubit_number)
_initializer.initialize(circuit_prep, coeffs, [qr[i] for i in range(len(qr))])

res = qiskit.execute(circuit_prep, statevector_backend).result()
statevector = res.get_statevector("initializerCirc")
print(statevector)

¹ यहाँ "त्रुटि" आदर्श राज्य और सन्निकटन के बीच की त्रुटि को संदर्भित करता है जब एक पूर्ण क्वांटम कंप्यूटर (यानी कोई डिकॉयर्स, कोई गेट त्रुटि) के साथ काम नहीं करता है।

— Nelimee
स्रोत

4 x 4 मैट्रिक्स के साथ HHL एल्गोरिथ्म IBM कंप्यूटर के लिए बड़ा हो सकता है। मैंने रेखीय समीकरणों के अर्क्सिव 1302.1210 लिंक सॉल्विंग सिस्टम के साथ एल्गोरिथ्म के एक छोटे से खिलौना संस्करण की कोशिश की

मैंने इस सर्किट के बारे में स्टैकएक्सचेंज में यहाँ थोड़ा सा समझाया: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-fhan-a-classical-computer/ 77036 # 77036

दुर्भाग्य से यह ए = 2 x 2 मैट्रिक्स के साथ केवल 1 क्वबिट इनपुट है, जवाब में आईबीएम सर्किट का लिंक दिया गया है।

— ब्रैम
स्रोत

4x4 एचएचएल कार्यान्वयन के साथ समस्या qubits की संख्या नहीं है (7 qubits की जरूरत है), लेकिन क्वांटम गेट्स त्रुटि दर और decoherence बार। QISKit का उपयोग करके 4x4 सिस्टम का कार्यान्वयन यहां उपलब्ध है । कार्यान्वयन arxiv.org/abs/1110.2232v2 का अनुसरण करता है ।

— नेल्लीमे

4 x 4 HHL का शानदार कार्यान्वयन।

— ब्राम