[PYTHON] Implémentation informatique quantique de Quantum Walk 3

Implémentation informatique quantique de la marche quantique 3 ~ Marche d'Adamal au cycle 3 ~

*** Résumez la mise en œuvre d'Adamal Walk au cycle 3 $ $ ***. Dans Quantum Walk Quantum Computer Implementation 2, nous avons introduit le cas où la taille du cycle est $ 2 ^ n $, mais nous avons également introduit le cas où la taille du cycle n'est pas $ 2 ^ n $. Faire. Implémentez une taille de cycle simple de 3 $. 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 3

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 (00,01,10 $ (0-2 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 de pièce et de décalage sont indiqué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 3 $.

• 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, *** Coin agoniste *** $ \ hat {C} = I \ otimes H $ peut être exprimé en ne passant $ H $ que par les bits quantiques de l'état. *** Agoniste de décalage *** $ \ hat {S} $ est -Si l'état est 0 '', l'emplacement x '' est -1 ・ Si l'état est 1 '', l'emplacement x '' est +1 Pensez à une porte à faire.

Implémentation dans IBM Q

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

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

Je voudrais considérer un algorithme pour l'opération +1 et l'opération -1 de $ n $ chiffre binaire, mais puisque $ q [0] q [1] $ contient également $ 11 $, il est nécessaire de bien l'éliminer. .. Par conséquent, sur la base du décalage de la marche quantique au cycle 4 (Implémentation informatique quantique 1 de la marche quantique), ajoutez la partie Switch excluant le cycle non lié. ..

• -1 opération (l'état est 0) Cycle 4-1 opération+Commutateur pour les emplacements 11 et 10=Cycle 3-1 opération
  

• +1 opération (l'état est 1) Cycle 4+1 opération+Commutateur pour les emplacements 11 et 00=Cycle 3+1 opération
  

Pour résumer ce qui précède, l'agoniste de décalage est Il devient. Agoniste de décalage du cycle 4 </ font> + Emplacement 11 et 10 commutateurs pour l'état 0 </ font> + État 1 Commutateurs d'emplacement 11 et 00 </ font>

from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute

from qiskit.tools.visualization import plot_histogram

q = QuantumRegister(3, 'q')
c = ClassicalRegister(2, 'c')

qwqc = QuantumCircuit(q,c)

#temps
t=1

#Définir l'état initial
qwqc.h(q[2])
qwqc.s(q[2])

#Développement du temps
for i in range(t):
    #Opération de monnaie
    qwqc.h(q[2])
    #décalage
    qwqc.x(q[1])
    qwqc.cx(q[2],q[0])
    qwqc.cx(q[1],q[0])
    #-1 tour fixe
    qwqc.x(q[2])
    qwqc.ccx(q[0],q[2],q[1])
    qwqc.x(q[2])
    #+1 tour fixe
    qwqc.ccx(q[1],q[2],q[0])
    qwqc.x(q[0])
    qwqc.ccx(q[0],q[2],q[1])
    qwqc.x(q[0])
    qwqc.ccx(q[1],q[2],q[0])
    
#Observation
qwqc.measure(q[0],c[0])
qwqc.measure(q[1],c[1])

qwqc.draw()

from qiskit import BasicAer
backend_s=BasicAer.get_backend('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)

from qiskit.tools.monitor import job_monitor
provider = IBMQ.get_provider(hub='ibm-q')

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

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