Implémentation informatique quantique de la marche quantique 2 ~ Marche d'Adamal à cheval au cycle 2 ~

*** Résumez la mise en œuvre d'Adamal Walk sur le cycle 8 $ $ ***. Si le cycle 8 est réalisé, le cycle $ 2 ^ n $ peut être augmenté de la même manière, donc seul le cas du cycle 8 sera introduit. La méthode présentée ici est la même que Implémentation efficace du circuit quantique des marches quantiques.

À propos de Hadamard Walk au cycle 8

Pour une brève explication de la marche quantique, reportez-vous à Quantum Walk Quantum Computer Implementation 1.

Le cycle auquel penser cette fois est

Est. Définir une marche quantique sur ce cycle (000,001 $, ..., 110111 $ (0-7 en décimal))

Agents de pièces et de quart

Comme la dynamique globale $ W=\hat{S}\hat{C}\\ $ Il est représenté par. Les éléments d'action de pièce et les éléments d'action de décalage sont présentés ci-dessous.

Agoniste de pièces $ \ hat {C} $

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

Agoniste de décalage $ \ hat {S} $

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

Laisser. Cependant, $ x \ pm 1 $ est considéré comme $ mod 8 $.

Etat initial $\Psi=\frac{1}{\sqrt{2}}|0\rangle\otimes|0\rangle+\frac{i}{\sqrt{2}}|0\rangle\otimes|1\rangle$

Compte tenu des portes de l'activateur de pièces '' et de l'activateur de décalage '' ``, l'évolution temporelle de la marche quantique peut être exprimée comme la marche quantique.

En particulier, *** L'agoniste des pièces *** $ \ hat {C} = I \ otimes H $ peut être exprimé en passant $ H $ uniquement à travers les bits quantiques de l'état. *** Agoniste de décalage *** $ \ hat {S} $ est -Si l'état $ q [3] $ est `0```, alors $ q [0] q [1] q [2] $ correspondant à l'emplacement x``` vaut -1. -Si l'état $ q [3] $ est `` 1```, le $ q [0] q [1] q [2] $ correspondant à l'emplacement `` x``` est +1. Pensez à une porte à faire.

Implémentation dans IBM Q

4qubits ($ q [0] q [1] q [2] q [3] $) est utilisé pour cette implémentation. Considérons $ q [0] q [1] q [2] $ comme le qbit correspondant à l'emplacement (000,001, ..., 110,111) et $ q [3] $ comme le qubit correspondant à l'état.

Construction d'agonistes de décalage (pour le cycle 8)

Considérant l'algorithme de +1 opération et -1 opération de $ n $ chiffre binaire

-1 opération
+1 opération devenir. Si vous entrez un nombre binaire à n chiffres, ce sera respectivement $ \ pm 1 $.

Chacune de ces portes peut être contrôlée par l'état $ q [3] $. Par conséquent, l'agoniste de décalage est le suivant. Dans cadre rouge </ font>, si le qubit le plus bas est 0 '', les 3 qubits supérieurs sont -1. Dans <font color = "Blue"> cadre bleu </ font>, si le qubit le plus bas est 1 '', les 3 premiers qubits sont +1.

Cependant, afin de l'implémenter avec IBM-Q, la porte toffoli avec au moins trois parties de contrôle doit être réécrite comme suit.

Création d'une partie circuit

Registre quantique, registre classique et configuration du circuit quantique qwqc à partir d'eux

Préparez-vous à réécrire la porte de toffoli.

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

Utilisez ce remplacement pour créer le code du cycle 8.

Emplacement qbits $ \ Rightarrow q [0] q [1] q [2] $
État qbits $ \ Rightarrow q [3] $
Qbits de réserve $ \ 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 fois le développement du temps
t=1

#Réglage initial
qwqc.h(q[3])
qwqc.s(q[3])

for i in range(t):
    #pièce de monnaie
    qwqc.u3(pi/3,0,0,q[3])
    #décalage-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])
    #décalage+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()

Résultat du simulateur avec 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)

\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}

Donc $\mu(1)=\mu(7)=\frac{1}{2}$ Le résultat est presque le même que la théorie.

Résultats de la machine réelle à 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)

Au cycle 8, le nombre de portes de contrôle est important et même une évolution ponctuelle entraîne une grande accumulation d'erreurs.

Résumé

On peut voir que plus le cycle est long, plus l'accumulation d'erreurs dans la machine réelle est grande. Si vous faites des agents de quart de la même manière, vous pouvez augmenter le cycle à 8,16,32 $, .... $.

Cette méthode de mise en œuvre est à la base des algorithmes et des systèmes quantiques $ n $ qubits qui ont une marche quantique cyclique en arrière-plan.

Implémentation informatique quantique de Quantum Walk 2