पुस्तक "क्वांटम कंप्यूटर का उपयोग कर विकास"

अंश। गेम थ्योरी: क्वांटम यांत्रिकी के साथ, लाभ हमेशा आपकी तरफ होता है

• नकली सिक्के की पहेली। यह 1945 में गणितज्ञ ईडी शेल द्वारा प्रस्तावित क्लासिक वजन समस्या है। इसमें, सीमित संख्या में वजन के लिए प्रयोगशाला पैमाने का उपयोग करते हुए, आपको एक सिक्का निर्धारित करने की आवश्यकता होती है जिसका वजन दूसरों के वजन (झूठे) से भिन्न होता है।
• मर्मिन का जादुई वर्ग - पेरेज़। यह क्वांटम छद्म टेलीपैथी, या खिलाड़ियों के परिणाम प्राप्त करने की क्षमता का एक उदाहरण है जो केवल तभी संभव है जब वे खेल के दौरान एक-दूसरे के विचारों को पढ़ते हैं।

नकली सिक्के की पहेली

• यदि दायां कटोरा बाहर निकलता है, तो गलत - सिक्का 1।
• यदि बाएं कटोरे से बाहर निकलता है, तो झूठे एक - सिक्का 2।
• यदि शेष राशि संतुलित है, तो झूठी - सिक्का 3।

• यदि दायां कटोरा बाहर निकलता है, तो गलत है - सिक्का 4।
• यदि बाएं कटोरे से बाहर निकलता है, तो झूठे एक - सिक्का 5।
• यदि शेष राशि संतुलित है, तो गलत है - सिक्का 6।

• यदि दायां कटोरा बाहर निकलता है, तो गलत है - सिक्का 7।
• यदि बाएं कटोरे से बाहर निकलता है, तो नकली सिक्का 8।

नोट
यह साबित हो गया है कि क्लासिक कंप्यूटर पर प्रयोगशाला संतुलन का उपयोग करके एक नकली सिक्के का पता लगाने के लिए कम से कम दो प्रयासों की आवश्यकता है।

क्वांटम समाधान

नोट
नकली सिक्का निर्धारित करने के लिए क्वांटम एल्गोरिथ्म अपने क्लासिक समकक्ष की तुलना में चौथे-डिग्री त्वरण का एक उदाहरण है।

चरण 1. क्वांटम वेट के लिए अनुरोध

नोट
किसी स्ट्रिंग के हैमिंग वेट (hw) वर्णों के उपयोग किए गए वर्ण के अशक्त वर्ण के अलावा अन्य वर्णों की संख्या है। उदाहरण के लिए, hw (11101) = 4, hw (11101000) = 4, hw (000000) = 0।

नोट
धारणा को आसान बनाने के लिए, नकली सिक्के का निर्धारण करने के लिए कार्यक्रम को 7.1-7.3 की सूची में विभाजित किया गया है। हालाँकि मुझे उम्मीद है कि आप इन लिस्टिंग को प्रोग्राम को चलाने के लिए जोड़ सकते हैं, फ़ाइल में पूर्ण कोड स्रोत में है Workspace\Ch07\p_counterfeitcoin.py।

# -------    
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])

#  numberOfCoins +1 / 
#      
#  
qr = Q_program.create_quantum_register("qr", numberOfCoins + 1)

#     qr
cr = Q_program.create_classical_register("cr", numberOfCoins + 1)

circuitName = "QueryStateCircuit"
circuit = Q_program.create_circuit(circuitName, [qr], [cr])

N = numberOfCoins

#       N
for i in range(N):
     circuit.h(qr[i])

#  XOR(x)     CNOT  qr[0]
#  qr[N–1]     qr[N]
for i in range(N):
     circuit.cx(qr[i], qr[N])

#  qr[N]     cr[N]. ,
#  cr[N]  ,     
circuit.measure(qr[N], cr[N])

#     ,     
# cr[0]...cr[N],     |1>,
#   |0> - |1>  qr[N]
circuit.x(qr[N]).c_if(cr, 0)
circuit.h(qr[N]).c_if(cr, 0)

#      cr[N]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 2**N)

चरण 2. क्वांटम वेट बनाना

#-----   
k = indexOfFalseCoin

#       
# (  cr,  )
circuit.cx(qr[k], qr[N]).c_if(cr, 0)

चरण 3. एक नकली सिक्के की पहचान करें

# ---   
#     qr[0] ... qr[N-1]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 0)

#  qr[0] ... qr[N–1]
for i in range(N):
     circuit.measure(qr[i], cr[i])

results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)

print("Device " + backend + " counts " + str(answer))

#     
for key in answer.keys():
     normalFlag, _ = Counter(key[1:]).most_common(1)[0]

for i in range(2,len(key)):
     if key[i] != normalFlag:
          print("False coin index is: ", len(key) - i - 1)

• यदि सबसे बाईं ओर 0 है, तो हमने नकली सिक्के की सफलतापूर्वक पहचान कर ली है;
• यदि सबसे बाईं ओर 1 है, तो हमें वांछित सुपरपोजिशन नहीं मिला है और फिर से प्रक्रिया को दोहराना चाहिए।

import sys
import matplotlib.pyplot as plt
import numpy as np
from math import pi, cos, acos, sqrt
from collections import Counter
from qiskit import QuantumProgram
sys.path.append('../Config/')
import Qconfig

#      
import basic plot tools
from qiskit.tools.visualization import plot_histogram

def main(M = 16, numberOfCoins = 8 , indexOfFalseCoin = 6
      , backend = "local_qasm_simulator" , shots = 1 ):

      if numberOfCoins < 4 or numberOfCoins >= M:
           raise Exception("Please use numberOfCoins between 4 and ", M-1)
      if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
           raise Exception("indexOfFalseCoin must be between 0 and ",
           numberOfCoins-1)

      //   7.1–7.3 

#################################################
# main
#################################################
if __name__ == '__main__':
     M = 8                      #    
     numberOfCoins = 4          #  M-1,  M —   
     indexOfFalseCoin = 2             #   0, 1... numberOfCoins — 1

     backend = "ibmq_qasm_simulator"
     #backend = "ibmqx3"
     shots = 1                         #      

     main(M, numberOfCoins, indexOfFalseCoin, backend, shots)

नकली सिक्कों की किसी भी संख्या के लिए सामान्यीकृत एल्गोरिदम

• इनपुट पर
• एक क्वेरी स्ट्रिंग बनाई जाती है, जिसमें एन ट्राइसेन्स बिट्स जैसे 1 और -1 की संख्या के साथ होते हैं;
• उत्तर एक ऐसा सा है
  

नोट
ऑरेकल एल्गोरिथ्म का एक हिस्सा है, जिसे ब्लैक बॉक्स माना जाता है। इसका उपयोग योजनाओं को सरल बनाने और क्वांटम और शास्त्रीय एल्गोरिदम की जटिलता की तुलना करने के लिए किया जाता है। एक अच्छा अलंकरण तेज, बहुमुखी और लागू करने में आसान होना चाहिए।

लेखक के बारे में

विज्ञान संपादकों के बारे में