मैं एन-बिट टोफोली गेट को कैसे लागू कर सकता हूं?

Question

मैं n qubits द्वारा नियंत्रित एक टोफोली गेट बनाना चाहता हूं, और इसे QISKit में लागू करना चाहता हूं। क्या यह किया जा सकता है? यदि हां, तो कैसे?

Comments

प्रश्नोत्तर के लिए धन्यवाद। आपको यहां देखकर अच्छा लगा अली!

— जेम्स वूटटन

Answer 1

ऐसा करने का एक सरल तरीका चित्र 4.10 नीलसन और चुआंग में चित्रित किया गया है।

जहां यू कोई एकल-qubit रोटेशन हो सकता है (इस मामले में, एक एक्स गेट)।

यह सर्किट इस तरह से काम करता है: हम यू को केवल लक्ष्य क्वैबिट में लागू करना चाहते हैं यदि AND सभी नियंत्रण की मात्रा 1 है। एक सामान्य टोफोली हमें 2 qubits का AND देता है। इसलिए कुछ टोफोलिस का पीछा करते हुए, हम c1.c2.c3.c4.c5 प्राप्त कर सकते हैं, इस कैच के साथ कि कुछ "काम" (या ancilla) क्वैबिट्स को मध्यवर्ती परिणामों को संग्रहीत करने के लिए पेश किया गया है। अंतिम CU को लागू करने के बाद, हम लक्ष्य में अंतिम परिणाम प्राप्त करते हैं। अब हम उनकी गणनाओं को पूर्ववत् करके, उन्हें वापस लौटाकर, मध्यवर्ती कार्य को समाप्त कर सकते हैं। प्रतिवर्ती संगणना के इस मॉडल को "गणना-प्रति-असंगत" विधि के रूप में जाना जाता है, और पहली बार 1973 में चार्ली बेनेट द्वारा प्रस्तावित किया गया था ।

सर्किट का निर्माण करने और इसे देखने के लिए यहाँ QISKit कोड है:

from qiskit import QuantumRegister, QuantumCircuit

n = 5  # must be >= 2

ctrl = QuantumRegister(n, 'ctrl')
anc = QuantumRegister(n-1, 'anc')
tgt = QuantumRegister(1, 'tgt')

circ = QuantumCircuit(ctrl, anc, tgt)

# compute
circ.ccx(ctrl[0], ctrl[1], anc[0])
for i in range(2, n):
    circ.ccx(ctrl[i], anc[i-2], anc[i-1])

# copy
circ.cx(anc[n-2], tgt[0])

# uncompute
for i in range(n-1, 1, -1):
    circ.ccx(ctrl[i], anc[i-2], anc[i-1])
circ.ccx(ctrl[0], ctrl[1], anc[0])    

from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circ)

पैदावार:

Answer 2

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

कहाँ पे $V^2=U$। इस मामले में, एक ऐसा चाहता है$V^2=X$, और इसलिए

$$V = \frac{1}{2} \begin{pmatrix} 1+i & 1-i \\ 1-i & 1+i \\ \end{pmatrix} \ .$$

यह एक पुनरावर्ती परिभाषा है, इसलिए नियंत्रण n qubit गेट नियंत्रण n-1 qubit गेट के रूप में परिभाषित किया गया है। यह तब तक जारी रहेगा जब तक आप दो क्वैबिट गेट CNOT तक नहीं पहुंच जाते।

यह कार्यान्वयन थोड़ा मुश्किल है, हालांकि, एक सरल एक मौजूद है अगर कोई एक रिश्तेदार चरण को इकट्ठा करने का मन नहीं करता है (उसी कागज के लेम्मा 7.9 देखें)।

एक गेट को लागू करने के लिए जैसे $V$QISKIT में, आपको उन्नत एकल qubit फाटकों का उपयोग करने की आवश्यकता होगी ।

Comments

क्या किसी ने सिर्क पर इस गेट को लागू करने पर काम किया है?

— एनरिक सेगुरा

Answer 3

Qiskit के QuantumCircuit में कई मोड्स के साथ मल्टीपल-कंट्रोल टोफोली गेट बनाने के लिए mct मेथड है: बेसिक, बेसिक-डर्टी-एंसिला, एडवांस्ड, नॉनकिला। उदाहरण के लिए 3 नियंत्रण qubits के साथ Toffoli गेट:

from qiskit import QuantumCircuit, QuantumRegister

controls = QuantumRegister(3, "c_qb")
target = QuantumRegister(1, "t_qb")
circuit = QuantumCircuit(controls, target)

circuit.mct(controls, target[0], None, mode='advanced')

print(circuit)

आउटपुट:

c_qb_0: |0>──────■────────■────────────────■──────────────────────────────────■──────────────────────────────────■────────────────────
                 │      ┌─┴─┐            ┌─┴─┐                                │                                  │                    
c_qb_1: |0>──────┼──────┤ X ├──────■─────┤ X ├──────■────────■────────────────┼─────────────────■────────────────┼────────────────────
                 │      └───┘      │     └───┘      │      ┌─┴─┐            ┌─┴─┐             ┌─┴─┐            ┌─┴─┐                  
c_qb_2: |0>──────┼─────────────────┼────────────────┼──────┤ X ├──────■─────┤ X ├──────■──────┤ X ├──────■─────┤ X ├──────■───────────
           ┌───┐ │-pi/4 ┌───┐┌───┐ │pi/4 ┌───┐┌───┐ │-pi/4 ├───┤┌───┐ │pi/4 ├───┤┌───┐ │-pi/4 ├───┤┌───┐ │pi/4 ├───┤┌───┐ │-pi/4 ┌───┐
t_qb_0: |0>┤ H ├─■──────┤ H ├┤ H ├─■─────┤ H ├┤ H ├─■──────┤ H ├┤ H ├─■─────┤ H ├┤ H ├─■──────┤ H ├┤ H ├─■─────┤ H ├┤ H ├─■──────┤ H ├
           └───┘        └───┘└───┘       └───┘└───┘        └───┘└───┘       └───┘└───┘        └───┘└───┘       └───┘└───┘        └───┘