एक बहुत ही सरल क्वांटम कार्यक्रम कैसा दिखेगा?

15

" पहला प्रोग्रामेबल क्वांटम फोटोनिक चिप " पढ़ने के बाद । मैं बस सोच रहा था कि क्वांटम उलझाव का उपयोग करने वाले कंप्यूटर के लिए कौन सा सॉफ्टवेयर पसंद आएगा।

क्या विशिष्ट क्वांटम प्रोग्रामिंग के लिए कोड का कोई उदाहरण है? स्यूडोकोड या उच्च स्तरीय भाषा की तरह? विशेष रूप से, सबसे छोटा कार्यक्रम क्या है जिसका उपयोग बेल राज्य बनाने के लिए किया जा सकता है एक राज्य के लिए initialised से शुरूदोनों एक सिमुलेशन और आईबीएम के एक का उपयोगक्वांटम अनुभव, जैसे प्रोसेसरibmqx4?

| ψ ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left|\psi\right> = \frac{1}{\sqrt 2} \left(\left|00\right> + \left|11\right> \right)$

| ψ_{0} ⟩ = | 00 ⟩

$\left|\psi_0\right> = \left|00\right>$

पारंपरिक प्रोग्रामिंग से उलझाव तक वैचारिक छलांग लगाना इतना आसान नहीं है।

मुझे C का परिवाद भी मिल गया है ।

simulation ibm-q-experience programming

— DIDIx13
स्रोत

12

यह मानते हुए कि आप एक गेट-आधारित क्वांटम कंप्यूटर पर विचार कर रहे हैं, एक उलझी हुई स्थिति पैदा करने का सबसे आसान तरीका बेल राज्यों में से एक का उत्पादन करना है। निम्नलिखित सर्किट बेल अवस्था दर्शाता है । $\left| \Phi^+ \right>$

$\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

$\left| \psi_0 \right>$

| ψ_{0} ⟩ = | 00 ⟩

$\left| \psi_0 \right> = \left | 0 0 \right >$

$\left| \psi_1 \right>$

हडामर्ड-गेट पहले क्वेट पर लागू होता है जिसके परिणामस्वरूप निम्नलिखित हैं:

| ψ_{1} ⟩ = (H \otimes I) | 00 ⟩ = H | 0 ⟩ \otimes | 0 ⟩ = \frac{1}{\sqrt{2}} (| 0 ⟩ + | 1 ⟩) | 0 ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 10 ⟩)

$\left| \psi_1 \right> =(H \otimes I)\left | 0 0 \right > = H\left | 0 \right > \otimes \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 \right > + \left | 1 \right > \right ) \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 0 \right > \right )$

$\left| \psi_2 \right>$

अब एक CNOT गेट लगाया जाता है और दूसरी क्वाइल को फ़्लिप करता है लेकिन केवल जहाँ पहले वाले का मान होता है 1. परिणाम है

| ψ_{2} ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left| \psi_2 \right> = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 1 \right > \right )$

$\left| \psi_2 \right>$

यद्यपि उपरोक्त दृष्टिकोण आपको एक सामान्य अर्थ में प्रोग्रामिंग की तरह प्रतीत नहीं हो सकता है, राज्यों के लिए फाटकों को लागू करना मूल रूप से एक गेट-आधारित क्वांटिटी कंप्यूटर काम करता है। एब्सट्रैक्शन परतें मौजूद हैं जो आपको उच्च-स्तरीय प्रोग्रामिंग करने की अनुमति देती हैं, लेकिन आदेशों को फाटकों के अनुप्रयोग में अनुवाद करती हैं। आईबीएम क्वांटम अनुभव इंटरफ़ेस ऐसी सुविधाओं प्रदान करता है।

Microsoft की Q # जैसी भाषा में उपरोक्त उदाहरण इसके जैसा दिखाई दे सकता है:

operation BellTest () : ()
{
    body
    {
        // Use two qubits
        using (qubits = Qubit[2])
        {
            Set (One, qubits[0]);
            Set (Zero, qubits[1]);

            // Apply Hadamard gate to the first qubit
            H(qubits[0]);

            // Apply CNOT gate
            CNOT(qubits[0],qubits[1]);
         }
     }
}

एक अधिक विस्तृत संस्करण (माप सहित) यहां पाया जा सकता है: Microsoft: क्वांटम प्रोग्राम लिखना ।

— dtell
स्रोत

14

क्वांटम प्रोग्राम लिखने का एक तरीका QISKit के साथ है। इसका उपयोग IBM के उपकरणों पर प्रोग्राम चलाने के लिए किया जा सकता है। QISKit वेबसाइट निम्नलिखित कोड का टुकड़ा तुम जा पाने के लिए है, जो एक उलझ सर्किट के रूप में आप चाहते हैं पता चलता है। यह भी वही प्रक्रिया है जो डेटेल द्वारा उत्तर में है। मैं इस पर लाइन-दर-लाइन टिप्पणी करूंगा।

# import and initialize the method used to store quantum programs
from qiskit import QuantumProgram
qp = QuantumProgram()
# initialize a quantum register of two qubits
qr = qp.create_quantum_register('qr',2) 
# and a classical register of two bits
cr = qp.create_classical_register('cr',2) 
# create a circuit with them which we call 'Bell'
qc = qp.create_circuit('Bell',[qr],[cr]) 
# apply a Hadamard to the first qubit
qc.h(qr[0]) 
# apply a controlled not with the first qubit as control
qc.cx(qr[0], qr[1]) 
# measure the first qubit and store its result on the first bit
qc.measure(qr[0], cr[0]) 
# the same for the second qubit and bit
qc.measure(qr[1], cr[1]) 
# run the circuit
result = qp.execute('Bell') 
# extract the results
print(result.get_counts('Bell'))

ध्यान दें कि यहां 'निष्पादित' कमांड केवल प्रोग्राम को चलाने के लिए निर्दिष्ट करता है। अन्य सभी सेटिंग्स, जैसे कि आप जिस उपकरण का उपयोग करना चाहते हैं, जितनी बार आप आंकड़े प्राप्त करने के लिए इसे दोहराना चाहते हैं, आदि उनके डिफ़ॉल्ट मानों पर सेट हैं। 1024 शॉट्स के लिए ibmqx4 पर चलने के लिए, आप इसके बजाय उपयोग कर सकते हैं

results = qp.execute(['Bell'], backend='ibmqx4', shots=1024)

— जेम्स वॉटन
स्रोत

4

सबसे सरल क्वांटम प्रोग्राम जो मैं सोच सकता हूं वह एक (1-बिट) सच यादृच्छिक संख्या जनरेटर है। एक क्वांटम सर्किट के रूप में, यह इस तरह दिखता है:

$|0 \rangle$ $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$ $|0\rangle$ $|1\rangle$

— पिरामिड
स्रोत