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 image.png

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.

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

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é. ..

Pour résumer ce qui précède, l'agoniste de décalage est image.png 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>

Création d'une partie circuit

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

  • Emplacement qbits $ \ Rightarrow q [0] q [1] $
  • État qbits $ \ Rightarrow q [2] $
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()

image.png

Résultat du simulateur avec t = 1

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)

image.png

Résultats de la machine réelle à t = 1

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)

Job Status: job has successfully run

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

image.png

Résumé

En faisant de même, il est possible de mettre en œuvre une marche quantique sur n'importe quelle taille de cycle. Pour l'implémentation du cycle arbitraire n, pour le plus petit $ N $ qui est $ n \ leq 2 ^ N $, décalez le cycle $ 2 ^ N $ [Quantum Walk Quantum Computer Implementation 2](https: // qiita. Un cycle arbitraire peut être créé en le créant par la méthode de com / YNUqw / items / 091f71ef71c75cbbc574) et en le modifiant en actionnant un commutateur.

Recommended Posts