Qiosit में सिंगल क्वांटम प्रोग्राम में कई क्वांटम सर्किट की रचना करना

Question

मैं सोच रहा था कि क्या प्रत्येक सर्किट के लिए पर रजिस्टर को पुन: व्यवस्थित करने के बिना कई क्वांटम सर्किट के साथ एक कार्यक्रम की रचना करने का एक तरीका है ।$0$

विशेष रूप से, मैं पहले उदाहरण के बाद एक दूसरा क्वांटम सर्किट चलाना चाहूंगा, जैसा कि इस उदाहरण में है:

qp = QuantumProgram()
qr = qp.create_quantum_register('qr',2)
cr = qp.create_classical_register('cr',2)

qc1 = qp.create_circuit('B1',[qr],[cr])
qc1.x(qr)

qc1.measure(qr[0], cr[0])
qc1.measure(qr[1], cr[1])

qc2 = qp.create_circuit('B2', [qr], [cr])
qc2.x(qr)
qc2.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])

#qp.add_circuit('B1', qc1)
#qp.add_circuit('B2', qc2)

pprint(qp.get_qasms())

result = qp.execute()

print(result.get_counts('B1'))
print(result.get_counts('B2'))

दुर्भाग्य से, मैं क्या मिलता है दो रन के लिए एक ही परिणाम (यानी एक की गिनती है 11के लिए B1और B2के बजाय 11और 00के रूप में अगर दूसरे के लिए, B2एक पूरी तरह से नए राज्य पर प्रारंभ पर चलाया जाता है 00के बाद B1।

Comments

तो क्या मैं इसे समझ सकता हूं कि आप एक लंबे सर्किट को कई हिस्सों से बनाना चाहते हैं, और आप प्रत्येक भाग के बाद आउटपुट देखना चाहते हैं?

— जेम्स वूटन

हाँ। कल्पना कीजिए कि मेरे पास एक कोड आधार है जो मुझे सर्किट देता है, और मैं उन्हें एक पहेली के रूप में रचना करने में सक्षम होना चाहता हूं :)

— asdf

(उपाय वहाँ केवल आपके पता चलता है कि अपेक्षित व्यवहार नहीं है)

— asdf

Answer 1

Qiskit में आप एक बड़ा सर्किट बनाने के लिए दो सर्किट की रचना कर सकते हैं। आप इसे केवल +सर्किट पर ऑपरेटर का उपयोग करके कर सकते हैं ।

यहाँ यह वर्णन करने के लिए आपका कार्यक्रम फिर से लिखा गया है (ध्यान दें: आपको इसके लिए Qiskit के नवीनतम संस्करण की आवश्यकता है, के साथ नवीनीकरण करें pip install -U qiskit)।

from qiskit import *
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc1 = QuantumCircuit(qr, cr)
qc1.x(qr)

qc2 = QuantumCircuit(qr, cr)
qc2.x(qr)

qc3 = qc1 + qc2

आप देख सकते हैं कि qc3 q1 और q2 का संयोजन है।

print(qc3.qasm())

पैदावार:

OPENQASM 2.0;
include "qelib1.inc";
qreg q0[2];
creg c0[2];
x q0[0];
x q0[1];
x q0[0];
x q0[1];

अब, आप दो बार राज्य की जांच करना चाहते हैं: एक बार जहां qc1 समाप्त होता है, और एक बार जब qc2 समाप्त होता है। आप snapshotकमांड डालकर एक सिम्युलेटर में ऐसा कर सकते हैं । यह सर्किट में दिए गए बिंदु पर स्टेटवेक्टर को बचाएगा। इससे राज्य का पतन नहीं होता है।

from qiskit.extensions.simulator import *
qc1.snapshot('0')    # save the snapshot in slot "0"
qc2.snapshot('1')    # save the snapshot in slot "1"
qc2.measure(qr, cr)  # measure to get final counts

qc3 = qc1 + qc2

अब आप qc3एक सिम्युलेटर पर अमल कर सकते हैं ।

job = execute(qc3, 'local_qasm_simulator')
result = job.result()
print(result.get_snapshot('0'))
print(result.get_snapshot('1'))
print(result.get_counts())

पैदावार: [0. + 0.j 0. + 0.j 0. + 0.j 1. + 0.j] [1. + 0.j 0. + 0.j 0. + 0.j 0. + 0.j] {'00': 1024}

इसलिए राज्य अपेक्षित रूप से ००.००> पर वापस चला जाता है।

Answer 2

एक बार जब आप एक माप करते हैं, तो क्वांटम राज्य / रजिस्टर की तरंग में गिरावट होती है और यह अपनी क्वांटम प्रकृति खो देता है। यह उस पर एक और सर्किट लागू करने के लिए समझ में नहीं आता है।

Comments

सुनिश्चित करें कि यह सुनिश्चित करें, लेकिन अगर मैं उपाय निकालने के लिए, मैं 00 पाने के लिए उम्मीद करेंगे, जब तक मैं 1. प्राप्त उपाय बस पता चलता है कि मैं 11 के लिए शुरू qubits के साथ दूसरा सर्किट शुरू करना चाहते है

— asdf

वास्तव में मैं चाहता हूं कि मेरी लहर क्वांटम अवस्था में गिर जाए और न कि 00 अगर आप इसे उस तरह से रखना चाहते हैं ...

— asdf

@ विद्या मैं समझता हूं कि यह ढह जाता है लेकिन मैं सहमत नहीं हूं कि पिछले सर्किट के ध्वस्त आउटपुट पर दूसरे सर्किट को लागू करने का कोई मतलब नहीं होगा।

— JanVdA