एक नमूना क्वांटम एल्गोरिथ्म, भाषाओं के प्रदर्शन के लिए उपयोगी

9

मैं एक क्वांटम एल्गोरिथ्म की तलाश कर रहा हूं जिसका उपयोग मैं विभिन्न क्वांटम-भाषाओं के वाक्य विन्यास को प्रदर्शित करने के लिए कर सकता हूं। मेरा प्रश्न इस के समान है , हालांकि, मेरे लिए, "अच्छा" का अर्थ है:

1-2 पैराग्राफ में इसका क्या वर्णन किया जा सकता है और इसे समझना आसान होना चाहिए।
"क्वांटम-प्रोग्रामिंग-वर्ल्ड" के अधिक तत्वों का उपयोग करना चाहिए (मेरा मतलब है कि एल्गोरिथ्म को कुछ शास्त्रीय स्थिरांक, माप, शर्तों, qregisters, ऑपरेटरों आदि का उपयोग करना चाहिए, जितना संभव हो)।
एल्गोरिथ्म छोटा होना चाहिए (अधिकतम 15-25 छद्म-रेखाएं लंबी)।

उपयोगी एल्गोरिदम अक्सर बहुत लंबे / कठिन होते हैं, लेकिन Deutsch का एल्गोरिथ्म कई तत्वों का उपयोग नहीं करता है। क्या कोई मुझे एक अच्छा-डेमो डेमो एल्गोरिथ्म सुझा सकता है?

algorithm resource-request programming

— klenium
स्रोत

क्या आपकी आवश्यकता यह भी है कि शास्त्रीय इनपुट और शास्त्रीय आउटपुट के साथ "एल्गोरिथम" होना चाहिए, और समान शास्त्रीय एल्गोरिदम काम करने के तरीके से स्पष्ट लाभ / अंतर होगा?

— DaftWullie

@DaftWullie ये आवश्यक नहीं हैं। एक ऑपरेटर का पैरामिटर या क्लासीकैन निरंतर इनिशियलाइज़ेशन मेरे लिए "इनपुट" का प्रतिनिधित्व कर सकता है, और ज़रूरत पड़ने पर आउटपुट स्वरूप प्रदान करूँगा। यह विशेष करने / करने की आवश्यकता नहीं है। फोकस भाषाओं के सिंटैक्स पर है, विवरण केवल यह पुष्टि करने के लिए है कि विभिन्न भाषाओं में कोड समान हैं। एल्गोरिथ्म का अर्थ अप्रासंगिक है।

— केलियम

क्वांटम कम्प्यूटिंग एसई में आपका स्वागत है! बस जांच करने के लिए, क्या आपके मानदंड एक अच्छे उत्तर के लिए सबसे कम छद्म कोड में सबसे अधिक तत्व हैं?

— मिथ्रंदिर 24601

1

@ मिथ्रंदिर 24601 धन्यवाद! हाँ, किसी तरह।

— केलियम

3

मैं सुझाव देता हूं कि प्रोटोकॉल को देखते हुए eigenvalue / eigenvector को देखें। समस्या को जितना आसान या जितना मुश्किल करना है, उतना आसान बनाने के लिए बहुत लचीलापन है।

दो मापदंडों को चुनकर शुरू करें, $n$ तथा $k$ । आप एक डिजाइन करना चाहते हैं $n$ - एकतरफा, $U$ कि फार्म के eigenvalues है $e^{-2\pi iq/2^k}$ पूर्णांकों के लिए $q$ । सुनिश्चित करें कि उनमें से कम से कम एक eigenvalues अद्वितीय है, और इसे कॉल करें $\omega$ । यह भी सुनिश्चित करें कि एक साधारण उत्पाद राज्य, कहते हैं $|0\rangle^{\otimes n}$ , नॉन-ज़ीरो ओवरलैप के साथ eigenvector of eigenvalue है $\omega$ ।

इसका उद्देश्य मूल्य के बारे में बताया जा रहा है, इस पर एक चरण आकलन एल्गोरिथ्म को लागू करना होगा $k$ , और एक वेक्टर के उत्पादन के साथ काम सौंपा जा रहा है $|\psi\rangle$ वह आइगेनवेक्टर है जो आइजनवेल्यू के अनुरूप है $\omega$ । सामान्य तौर पर इसमें एक सर्किट शामिल होगा $n+k$ qubits (जब तक आपको नियंत्रित लागू करने के लिए ancillas की आवश्यकता नहीं है- $U$ )।

यह निम्नानुसार काम करता है:

दो रजिस्टर, एक में से एक को स्थापित करें $k$ qubits, और के अन्य $n$ qubits। ( क्वांटम रजिस्टरों का उपयोग )

राज्य में हर क्वबिट को इनिशियलाइज़ किया गया है $|0\rangle$ । ( क्वांटम रजिस्टरों का आरंभ )

पहले रजिस्टर ( सिंगल-क्वैबिट गेट्स ) में प्रत्येक क्वैबिट में एक हैडमर्ड लागू करें

qubit से $r$ पहले रजिस्टर में, नियंत्रित लागू करें- $U^{2^{r}}$ , दूसरा रजिस्टर ( बहु-नियंत्रित नियंत्रित द्वार ) को लक्षित करना

उलटा फूरियर रूपांतरण को पहले रजिस्टर पर लागू करें, और मानक आधार में पहले रजिस्टर के हर qubit को मापें। इन्हें अर्ध-शास्त्रीय फूरियर रूपांतरण को लागू करते हुए जोड़ा जा सकता है । ( माप और फ़ीड-शास्त्रीय डेटा के आगे )

सही माप परिणाम के लिए, दूसरा रजिस्टर वांछित स्थिति में है $|\psi\rangle$ ।

सादगी के लिए, आप चुन सकते हैं $n=2$ , $k=1$ , तो आप एक की जरूरत है $4\times 4$ eigenvalues के साथ एकात्मक मैट्रिक्स $\pm 1$ । मैं कुछ का उपयोग करता हूँ

(U_{1} \otimes U_{2}) C (U_{1}^{†} \otimes U_{2}^{†}),

$(U_1\otimes U_2)C(U_1^\dagger\otimes U_2^\dagger),$ कहाँ पे

C

$C$ नियंत्रित-नहीं को दर्शाता है। Eigenvalue -1 के साथ सिर्फ एक eigenvector है, जो कि है

| ψ ⟩ = (U_{1} \otimes U_{2}) | 1 ⟩ \otimes (| 0 ⟩ - | 1 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$ , और आप के विकल्पों के साथ गड़बड़ कर सकते हैं

U_{1}

$U_1$ तथा

U_{2}

$U_2$ के कार्यान्वयन का पता लगाने के लिए

U

$U$ एक सार्वभौमिक गेट सेट के संदर्भ में अपघटन का उपयोग करना (मैं शायद इसे प्रारंभिक समस्या के रूप में सेट करूँगा)। फिर, नियंत्रित-

U

$U$ एक नियंत्रित नियंत्रित-नॉट (टोफोली) गेट के साथ नियंत्रित-नहीं की जगह बस आसानी से लागू किया जाता है। अंत में, उलटा फूरियर रूपांतरण सिर्फ एक हैमर्ड द्वार है।

कुछ और अधिक जटिल के लिए, डाल दिया $k=3$ , और प्रतिस्थापित करें $C$ स्वैप गेट के वर्गमूल के साथ,

(\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \end{array})

$\left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \\ \end{array} \right)$ with

ω = e^{\pm i π / 4}

$\omega=e^{\pm i\pi/4}$ and

| ψ ⟩ = (U_{1} \otimes U_{2}) (| 01 ⟩ \pm | 10 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$ .

— DaftWullie
स्रोत

3

Sounds like you want a quantum "Hello World". The most straightforward quantum version of this would just be to write a binary encoded version of the text Hello World in a register of qubits. But this would require ~100 qubits, and be longer than your upper limit for code length.

So let's write a shorter peice of text. Let's write ;), we need a bit string of length 16. Specifically, using ASCII encoding

;)  =  00111011 00101001

Using QISKit, you'd do this using the following code.

from qiskit import QuantumProgram
import Qconfig

qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url

# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])

# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])

# second eight (qu)bits have 00111011
# these differ only on the rightmost two bits
qc.x(qr[9])
qc.x(qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])

# measure
for j in range(16):
    qc.measure(qr[j], cr[j])

# run and get results
results = qp.execute(["smiley_writer"], backend='ibmqx5', shots=1024)
stats = results.get_counts("smiley_writer")

Of course, this isn't very quantum. So you could do a superposition of two different emoticons instead. The easiest example is to superpose ;) with 8), since the bit strings for these differ only on qubits 8 and 9.

;)  =  00111011 00101001
8)  =  00111000 00101001

So you can simply replace the lines

qc.x(qr[9])
qc.x(qr[8])

from the above with

qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot

The Hadamard creates a superposition of 0 and 1, and the cnot makes it into a superposition of 00 and 11 on two qubits. This is the only required superposition for ;) and 8).

If you want to see an actual implementation of this, it can be found on the QISKit tutorial (full disclosure: it was written by me).

— James Wootton
स्रोत

I get 404 for that link. Did you move the file elsewhere?

— klenium

It seems the tutorial was just updated. I changed the link, so it should work now.

— James Wootton

1

I would propose the (perfect) 1-bit random number generator. It is almost trivially easy:

You start with a single qubit in the usual initial state $\left|0\right>$ . Then you apply the Hadamard gate $H$ which produces the equal superposition of $\left|0\right>$ and $\left|1\right>$ . Finally, you measure this qubit to get either 0 or 1, each with 50% probability.

— pyramids
स्रोत