Lab09_QuantumSimulationSearchAlgorithm.ipynb

Kernel: Python 3

অনুসন্ধান অ্যালগরিদম হিসাবে ল্যাব 9 কোয়ান্টাম সিমুলেশন

পূর্বশর্ত:

• Ch.3.8 Grover's Algorithm

• Ch.2.5 Proving Universality

অন্যান্য প্রাসঙ্গিক উপকরণ:

• [Ch 6.2 in QCQI] Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information, p255

from qiskit import *
from qiskit.quantum_info import Statevector, partial_trace
from qiskit.visualization import plot_state_qsphere, plot_histogram

import numpy as np
import matplotlib.pyplot as plt
import scipy.linalg as la

sim = Aer.get_backend('qasm_simulator')

পার্ট 1: হ্যামিলটোনিয়ান সিমুলেশন

গোল

এই ল্যাবে, আমরা একটি প্রদত্ত হ্যামিলটোনিয়ান দ্বারা উত্পন্ন একটি বিবর্তন প্রক্রিয়া হিসাবে veiwed একটি কোয়ান্টাম অবস্থার পরিবর্তন বিবেচনা করি। একটি নির্দিষ্ট হ্যামিল্টোনিয়ানের জন্য, একটি সংশ্লিষ্ট ইউনিটারি অপারেটর রয়েছে যা যে কোনো প্রদত্ত প্রাথমিক অবস্থার জন্য চূড়ান্ত অবস্থা নির্ধারণ করে।

একটি প্রাথমিক অবস্থার জন্য, $|\psi(0)\rangle$ এবং একটি সময় স্বাধীন হ্যামিল্টোনিয়ান $H$, চূড়ান্ত অবস্থা $|\psi(t)\rangle$ হল $|\psi(t)\rangle = e^ {-iHt}|\psi(0)\rangle$। অতএব, একক অপারেটর $e^{-iHt}$-এর জন্য একটি উপযুক্ত গেট তৈরি করে, আমরা একটি কোয়ান্টাম সার্কিট তৈরি করতে পারি যা কোয়ান্টাম অবস্থা $|\psi\rangle$ এর বিবর্তনকে অনুকরণ করে।

1. একটি প্রদত্ত হ্যামিলটোনিয়ানের জন্য একটি কোয়ান্টাম সার্কিট তৈরি করুন।

যখন হ্যামিলটোনিয়ান $H$ এবং সিস্টেমের প্রাথমিক অবস্থা, $|\psi(0)\rangle$, দেওয়া হয়

$H = |0\rangle\langle0| + |+\rangle\langle+|, ~~~~ |\psi(0)\rangle = |+\rangle = \frac{1}{\sqrt 2}(|0\rangle + |1\rangle)$.

$\Delta t = \theta$, যেখানে সিস্টেমের অবস্থা 0 তম qubit-এ এনকোড করা হয়, সেখানে $|\psi(0\rangle$, $H$ দ্বারা একটি সময়ের জন্য $\Delta t = \theta$, $|\psi(0\rangle$) দিয়ে দুটি কিউবিট দিয়ে সার্কিটটি তৈরি করুন। ১ম কিউবিট একটি সহায়ক। তারপর, চূড়ান্ত অবস্থা $|\psi(\theta)\rangle$ হল $|\psi(\theta)\rangle = e^{-i\theta ~ ( |0\rangle\langle0 | ~ + ~ |+\rangle\langle+| )}~|\psi(0)\rangle$।

📓ধাপ A. দেখান যে নিচের সার্কিট থেকে গেট H1 $e^{-i\frac{\pi}{9}|0\rangle\langle0|}$ 0ম কিউবিটে অপারেশন করে যখন সিস্টেমের অবস্থা 0ম কিউবিটে এনকোড করা হয়েছে এবং 1ম কিউবিট, সহায়ক, $|0\rangle$ অবস্থায় সেট করা আছে।

h1 = QuantumCircuit(2, name = 'H1')

h1.cnot(0, 1)
h1.p(np.pi/9, 1)
h1.cnot(0, 1)

H1 = h1.to_gate()

h1.draw()

আপনার সমাধান :

📓ধাপ B. 0 তারিখে $e^{-i\frac{\pi}{9}|+\rangle\langle+|}$ সম্পাদন করতে সার্কিট `h2` এর জন্য নিম্নলিখিত কোডটি সম্পূর্ণ করে গেট H2 তৈরি করুন qubit যখন সিস্টেমের অবস্থা 0ম qubit-এ এনকোড করা হয় এবং 1ম qubit, সহায়ক, $|0\rangle$ অবস্থায় সেট করা হয়।

h2 = QuantumCircuit(2, name='H2')

#### Your code goes here ###







#############################

H2 = h2.to_gate()

h2.draw()

2. প্রতিটি পুনরাবৃত্তির পরে 0 তম কিউবিটের অবস্থা তৈরি করতে নীচের ঘরটি চালান।

সার্কিট $(H1H2)^7|+\rangle = (~ e^{-i\frac{\pi}{9} ~ |0\rangle\langle0|}e^{-i\frac{\pi} সম্পাদন করে {9}~|+\rangle\langle+|} ~)^7~|+\rangle$ 0ম কিউবিটে। প্রতিটি H1H2 অপারেশনের পর 0 তম qubit-এর অবস্থা তালিকা ভেরিয়েবল 'myst'-এ সংরক্ষণ করা হয়।

from qiskit.quantum_info import Statevector, partial_trace

def st_out(qc):
    out = Statevector.from_instruction(qc)
    out_red = partial_trace(out, [1])
    prob, st_all = la.eig(out_red.data)
    cond = (prob>0.99) & (prob<1.01)
    st = st_all[:, cond].ravel()
    
    return(st)
    
myst = []

circ = QuantumCircuit(2)
circ.h(0)
st = st_out(circ)
myst.append(Statevector(st))

for _ in range(7):
    circ.append(H1, range(2))
    circ.append(H2, range(2))
    st = st_out(circ)
    myst.append(Statevector(st))
    
circ.draw() 

নিচের ব্লচ গোলকের ছবি 0ম কিউবিট অবস্থার বিবর্তন দেখায়। যেমনটি দেখায়, স্টেট $|+\rangle$ স্টেট থেকে শুরু হয় এবং $|0\rangle$ স্টেটের দিকে ঘোরে। অতএব, H1 এবং H2 অপারেশনগুলির উপযুক্ত কোণ সহ, $|+\rangle$ রাষ্ট্র $H1H2 = e^{-i\theta ~ |0\rangle\langle0|} প্রয়োগ করে$|0\rangle$অবস্থায় বিবর্তিত হয়। e^{-i\theta~|+\rangle\langle+|}$ সঠিক সংখ্যক বার।

Ch.3.8 Grover's Algorithm

আপনি যদি kaleidoscope ইনস্টল করে থাকেন বা IQX- এ এই ল্যাবটি চালান, তাহলে আপনি ইন্টারেক্টিভ ব্লোচ গোলকের মাধ্যমে রাষ্ট্রের বিবর্তন কল্পনা করতে নীচের সেলটি চালাতে পারেন।

from kaleidoscope import bloch_sphere
from matplotlib.colors import LinearSegmentedColormap, rgb2hex

cm = LinearSegmentedColormap.from_list('graypurple', ["#999999", "#AA00FF"])
vectors_color = [rgb2hex(cm(kk)) for kk in np.linspace(-1,1,len(myst))]
bloch_sphere(myst, vectors_color = vectors_color)

পার্ট 2: কোয়ান্টাম সিমুলেশন হিসাবে কোয়ান্টাম অনুসন্ধান

গোল

ল্যাবের এই অংশে, আমরা কোয়ান্টাম সিমুলেশনের মাধ্যমে একটি অনুসন্ধান সমস্যা সমাধান করি।

অংশ 1-এ, আমরা দেখিয়েছি যে হ্যামিলটোনিয়ান, $H$, রাষ্ট্রকে $|\psi_i\rangle$, $|\psi_j\rangle$ এ রূপান্তরিত করে যখন এর গঠন উভয় অবস্থার উপর নির্ভর করে $H =|\psi_j\rangle\ হিসাবে langle\psi_j| + |\psi_i\rangle\langle\psi_i|$ একটি সঠিক সময়কাল সহ।

একটি অনন্য সমাধানের সাথে একটি অনুসন্ধান সমস্যা বিবেচনা করে, আমাদের হ্যামিলটোনিয়ান, $H = |x\rangle\langle x| + |\psi\rangle\langle\psi|,$ যখন সমস্ত সম্ভাব্য আইটেম একটি সুপারপজিশন অবস্থায় এনকোড করা হয় $|\psi\rangle$ এবং প্রাথমিক অবস্থা হিসাবে দেওয়া হয়, গ্রোভারের অ্যালগরিদমের মতো, যখন $|x\rangle$ অজানা সমাধান প্রতিনিধিত্ব করে।

একক অপারেটর প্রয়োগ করলে, $U = e^{-iH\Delta t}$ প্রাথমিক অবস্থায়, $|\psi\rangle$, সঠিকভাবে নির্বাচিত $\Delta t$ সহ বারবার সঠিক সংখ্যা, রাষ্ট্র $বিবর্তিত হওয়া উচিত। |\psi\rangle$ সমাধানে $|x\rangle$ বা এটির যথেষ্ট কাছাকাছি। নিম্নলিখিত কোডটি অনুসন্ধান সমস্যার জন্য ওরাকল গেট তৈরি করে। নিচের সেলটি এক্সিকিউট করুন।

n = 5
qc = QuantumCircuit(n+1, name='Oracle')
qc.mct(list(range(n)), n)

Oracle = qc.to_gate()

নিম্নোক্ত সার্কিটটি সল্যুশন স্টেটে ফেজ $\pi$কে এনকোড করে এবং অন্যান্য আইটেমগুলিতে শূন্যকে ফেজ কিকব্যাকের মাধ্যমে 5ম কিউবিট সহ সহায়ক হিসাবে। অতএব, সার্কিটের আউটপুট অবস্থা হল $(|\psi\rangle - |x\rangle) + e^{i\pi}|x\rangle$, যা একটি qsphere প্লট ব্যবহার করে দৃশ্যত নিশ্চিত করা যেতে পারে যেখানে রঙ নির্দেশ করে প্রতিটি ভিত্তি রাষ্ট্রের পর্যায়। নিম্নলিখিত দুটি কোষ চালান।

test = QuantumCircuit(n+1)
test.x(n)
test.h(range(n+1))
test.append(Oracle, range(n+1))
test.h(n)

test.draw()

st = Statevector.from_instruction(test)
st_red = partial_trace(st, [5])

plot_state_qsphere(st_red)

1. হ্যামিলটোনিয়ান, $H = |x\rangle\langle x| আনুমানিক একটি সার্কিট তৈরি করুন + |\psi\rangle\langle\psi|$, যখন সমস্ত সম্ভাব্য আইটেম একটি সুপারপজিশন অবস্থায় এনকোড করা হয় $|\psi\rangle$ এবং প্রাথমিক অবস্থা হিসাবে দেওয়া হয় যখন $|x\rangle$ অনন্য অজানা সমাধান উপস্থাপন করে।

আমরা যেমন পার্ট 1 এ করেছি, আমরা হ্যামিলটোনিয়ানের সাথে সিমুলেশনের জন্য সার্কিট তৈরি করি, কিন্তু প্রশ্নের সমস্ত আইটেম পরীক্ষা করার জন্য আরও কিউবিট দিয়ে। 32টি আইটেমের মধ্যে একটি সমাধান থাকা অনুসন্ধানের সমস্যাটি রেগ্রেড করুন।

📓 ধাপ A. নিচের কোডটি সম্পূর্ণ করে $e^{-i\Delta t|\psi\rangle\langle\psi|}$ অপারেশন সম্পাদন করে গেট H1 নির্মাণ করুন।

def H1(delt, n=5):
    
    h1 = QuantumCircuit(n+1, name='H1')

    #### Your code goes here ######

    



    
    ###############################
    
    return h1.to_gate()

📓ধাপ B. নিচের কোডটি সম্পূর্ণ করে $e^{-i\Delta t|x\rangle\langle x|}$ অপারেশন সম্পাদন করে গেট H2 নির্মাণ করুন।

def H2(delt, n=5):
    
    h2 = QuantumCircuit(n+1, name='H2')

    #### Your code goes here ######

    
    
    
    
    
    
    
    ###############################
    
    return h2.to_gate()

📓ধাপ C. ParseError: KaTeX parse error: Expected '}', got 'EOF' at end of input: …gle\langle\psi| প্রায় সময়কাল ধরে $\Delta t = \pi$।

Th state $|\psi\rangle$ সমস্ত সম্ভাব্য আইটেমের সুপারপজিশন অবস্থার প্রতিনিধিত্ব করে।

গেট H1 এবং H2 ব্যবহার করুন।

#### Your code goes here ####








############

sim_h.draw()

2. দেখান যে অনুসন্ধান সমস্যাটি কোয়ান্টাম সিমুলেশনের মাধ্যমে $H_{appr}$ এর মাধ্যমে সমাধান করা যেতে পারে দুটি অপারেশন, গ্রোভারের অ্যালগরিদম এবং $U = e^{-i\Delta t~H_{appr}}$ এর সাথে $\ যাচাই করে। ডেল্টা t = \pi$, সমতুল্য।

ধাপ A. নিচের সার্কিট, `grover`, সমস্যাটির জন্য Grover-এর অ্যালগরিদম চালায় যাতে আমরা উপরে যে ওরাকল তৈরি করেছি তার সমাধান খুঁজে পেতে। নিচের সেলটি চালান।

qc = QuantumCircuit(n+1, name='Amp')
qc.h(range(n))
qc.x(range(n))
qc.mct(list(range(n)), n)
qc.x(range(n))
qc.h(range(n))

Amp = qc.to_gate()

grover = QuantumCircuit(n+1)
grover.x(n)
grover.h(range(n+1))
grover.append(Oracle, range(n+1))
grover.append(Amp, range(n+1))
grover.h(n)
grover.x(n)

grover.draw()

ধাপ B. নীচের কোষগুলি চালানোর পরে, ফলাফল দেখায় যে সার্কিট, 'গ্রোভার' এবং 'সিম_এইচ' একটি বিশ্বব্যাপী পর্যায় পর্যন্ত অভিন্ন।

st_simh = Statevector.from_instruction(sim_h)
st_grover = Statevector.from_instruction(grover)
print('grover circuit and sim_h circuit genrate the same output state: ' ,st_simh == st_grover)

plot_state_qsphere(st_simh)

plot_state_qsphere(st_grover)

📓ধাপ C. আমাদের তৈরি করা ওরাকলের সমাধান খুঁজে বের করার জন্য প্রয়োজনীয় গ্রোভার ইন্টারেশান, R-এর সংখ্যা খুঁজুন।

#### your code goes here ####




######
print(R)

ধাপ D. গ্রোভারের অ্যালগরিদম এবং সিমুলেশন কম্পিউটিং $e^{-i R\pi H_{app}}|\psi\rangle = (~e^{ -i\pi~|x\rangle\langle x|}e^{-i\pi~|\psi\rangle\langle\psi|}~)^R|\psi\rangle$ যেখানে R হল পুনরাবৃত্তির সংখ্যা .

## The circuit to solve the search problem through Grover's algorithm. 
n = 5 

qc_grover = QuantumCircuit(n+1, n)
qc_grover.x(n)
qc_grover.h(range(n+1))
for _ in range(int(R)):
    qc_grover.append(Oracle, range(n+1))
    qc_grover.append(Amp, range(n+1))

qc_grover.h(n)
qc_grover.x(n)
qc_grover.barrier()
qc_grover.measure(range(n), range(n))


qc_grover.draw()

📓 সিমুলেশনের মাধ্যমে অনুসন্ধান সমস্যা সমাধানের জন্য সার্কিট, qc_sim তৈরি করার জন্য কোডটি সম্পূর্ণ করুন।

qc_sim = QuantumCircuit(n+1, n)
qc_sim.h(range(n))

#### Your code goes here ####

qc_grover এবং qc_sim উভয় সার্কিট অনুকরণ করতে নিম্নলিখিত ঘরটি চালান এবং তাদের সমাধান তুলনা করুন।

counts = execute([qc_grover, qc_sim], sim).result().get_counts()
plot_histogram(counts, legend=['Grover', 'Hamiltonian'])

3. নিম্নলিখিত ফলাফলটি একটি উদাহরণ দেখায় যেখানে সঠিক সময়কাল $\Delta t$ বেছে নেওয়ার মাধ্যমে কোয়ান্টাম সিমুলেশনের মাধ্যমে একের সমান সম্ভাব্যতার সাথে সমাধান পাওয়া যেতে পারে।

n = 5

qc = QuantumCircuit(n+1, n)
qc.h(range(n))

delt, R = np.pi/2.1, 6

for _ in range(int(R)):
    qc.append(H1(delt), range(n+1))
    qc.append(H2(delt), range(n+1))

qc.measure(range(n) ,range(n))    
qc.draw()

count = execute(qc, sim).result().get_counts()
plot_histogram(count)