[PYTHON] Quantum Computer Implementierung von Quantum Walk 2

Quantencomputer-Implementierung von Quantum Walk 2 ~ Reiten Adamal Walk in Zyklus 2 ~

*** Fassen Sie die Implementierung von Adamal Walk im Zyklus $ 8 $ zusammen ***. Wenn Zyklus 8 realisiert ist, kann Zyklus $ 2 ^ n $ auf die gleiche Weise erhöht werden, so dass nur der Fall von Zyklus 8 eingeführt wird. Die hier vorgestellte Methode ist dieselbe wie Effiziente Quantenschaltungsimplementierung von Quantenwanderungen.

Über Hadamard Walk auf Zyklus 8

Eine kurze Erläuterung des Quantenlaufs finden Sie unter Quantum Walk Quantum Computer Implementation 1.

Der Zyklus, um über diese Zeit nachzudenken, ist image.png

Ist. Definieren Sie einen Quantenlauf in diesem Zyklus ($ 000,001, ..., 110,111 $ (0-7 in Dezimalzahl)).

Münz- und Schichtagenten

Wie die Gesamtdynamik $ W=\hat{S}\hat{C}\\ $ Es wird vertreten durch. Münzaktionselemente und Verschiebungsaktionselemente werden unten gezeigt.

\hat{C}=(I\otimes H)\\
\mbox{jedoch}I=\sum_{x}|x\rangle\langle x|,\quad
H=\frac{1}{\sqrt{2}}\begin{bmatrix}
1&1\\1&-1
\end{bmatrix}

\hat{S}=\sum_{x}|x-1\rangle\langle x|\otimes|0\rangle\langle 0|+|x+1\rangle\langle x|\otimes|1\rangle\langle 1|

Lassen. $ X \ pm 1 $ wird jedoch als $ mod 8 $ betrachtet.

Unter Berücksichtigung der Tore des "Münzaktivators" und des "Verschiebungsaktivators" kann die zeitliche Entwicklung des Quantenlaufs als Quantenlauf ausgedrückt werden.

Speziell, *** Münzagonist *** $ \ hat {C} = I \ otimes H $ kann ausgedrückt werden, indem $ H $ nur durch die Quantenbits des Zustands geleitet wird. *** Shift Agonist *** $ \ hat {S} $ ist -Wenn der Zustand $ q [3] $ `0``` ist, ist $ q [0] q [1] q [2] $ entsprechend dem Ort x``` -1. -Wenn der Zustand $ q [3] $ "1" ist, ist das $ q [0] q [1] q [2] $, das dem Ort "x" entspricht, +1. Denken Sie an ein Tor zu tun.

Implementierung in IBM Q.

Für diese Implementierung werden 4 Qubits ($ q [0] q [1] q [2] q [3] $) verwendet. Betrachten Sie $ q [0] q [1] q [2] $ als das dem Ort entsprechende qbit (000,001, ..., 110,111) und $ q [3] $ als das dem Zustand entsprechende Qubit.

Konstruktion von Schichtagonisten (für Zyklus 8)

Betrachtet man den Algorithmus der +1 Operation und -1 Operation der $ n $ stelligen Binärzahl

Jedes dieser Tore kann durch den Zustand $ q [3] $ gesteuert werden. Daher ist der Verschiebungsagonist wie folgt. image.png Wenn im roten Rahmen </ font> das niedrigste Qubit "0" ist, sind die oberen 3 Qubits -1. Wenn im blauen Rahmen </ font> das niedrigste Qubit "1" ist, sind die oberen 3 Qubits +1.

Um es jedoch mit IBM-Q zu implementieren, muss das Toffoli-Gate mit drei oder mehr Steuerteilen wie folgt neu geschrieben werden. toffo1.png

Erstellung des Schaltungsteils

Quantenregister, klassisches Register und eingestellte Quantenschaltung qwqc von ihnen

Bereiten Sie sich darauf vor, das Toffoli-Tor neu zu schreiben.

def toffoli(circ,c1,c2,c3,t,a1):
    circ.ccx(c3,c2,a1)
    circ.ccx(a1,c1,t)
    circ.ccx(c3,c2,a1)

Verwenden Sie diesen Ersatz, um Code für Zyklus 8 zu erstellen.

  • Position qbits $ \ Rightarrow q [0] q [1] q [2] $
  • Geben Sie qbits $ \ Rightarrow q [3] $ an
  • Ersatz-Qbits $ \ Rightarrow aq [0] $
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute

from qiskit.tools.visualization import plot_histogram

q = QuantumRegister(4, 'q')
aq =QuantumRegister(1, 'aq')
c = ClassicalRegister(3, 'c')
qwqc = QuantumCircuit(q,aq,c)

#t mal Zeitentwicklung
t=1

#Grundeinstellung
qwqc.h(q[3])
qwqc.s(q[3])

for i in range(t):
    #Münze
    qwqc.u3(pi/3,0,0,q[3])
    #Verschiebung-1
    qwqc.x(q[3])
    qwqc.cx(q[3],q[2])
    qwqc.ccx(q[3],q[2],q[1])
    toffoli(qwqc,q[1],q[2],q[3],q[0],aq[0])
    qwqc.x(q[3])
    #Verschiebung+1
    toffoli(qwqc,q[1],q[2],q[3],q[0],aq[0])
    qwqc.ccx(q[3],q[2],q[1])
    qwqc.cx(q[3],q[2])
    
qwqc.measure(q[0],c[0])
qwqc.measure(q[1],c[1])
qwqc.measure(q[2],c[2])
qwqc.draw()

image.png

Simulatorergebnis mit t = 1

from qiskit import IBMQ

provider = IBMQ.get_provider(hub='ibm-q')

backend_s=provider.get_backend('ibmq_qasm_simulator')
job_s = execute(qwqc, backend_s,shots=1024)
result_s = job_s.result()
counts_s = result_s.get_counts(qwqc)
plot_histogram(counts_s)

image.png

\begin{align}
W\Psi&=SC\left(\frac{1}{\sqrt{2}}|0\rangle\otimes|0\rangle+\frac{i}{\sqrt{2}}|0\rangle\otimes|1\rangle\right)\\
&=\frac{1}{2}S\left((1+i)|0\rangle\otimes|0\rangle+(1-i)|0\rangle\otimes|1\rangle\right)\\
&=\frac{1}{2}\left((1+i)|7\rangle\otimes|0\rangle+(1-i)|1\rangle\otimes|1\rangle\right)
\end{align}

Deshalb $\mu(1)=\mu(7)=\frac{1}{2}$ Das Ergebnis ist fast das gleiche wie die Theorie.

Ergebnisse der tatsächlichen Maschine bei t = 1

from qiskit.tools.monitor import job_monitor

backend_r=provider.get_backend('ibmq_london')
job_r = execute(qwqc, backend=backend_r,shots=1024)
job_monitor(job_r)

Job Status: job has successfully run

result_r= job_r.result()
counts_r = result_r.get_counts(qwqc)
plot_histogram(counts_r)

image.png

In Zyklus 8 ist die Anzahl der Steuergatter groß, und selbst eine einmalige Entwicklung führt zu einer großen Anhäufung von Fehlern.

Zusammenfassung

Es ist ersichtlich, dass je größer der Zyklus ist, desto größer ist die Anhäufung von Fehlern in der tatsächlichen Maschine. Wenn Sie Schichtagenten auf die gleiche Weise herstellen, können Sie den Zyklus auf 8,16,32 $, .... $ erhöhen.

Diese Implementierungsmethode ist die Basis für die $ n $ Qubits-Quantenalgorithmen und -systeme, die im Hintergrund einen zyklischen Quantenlauf haben.

Recommended Posts