Implémentation informatique quantique de Quantum Walk 2

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

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.

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

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

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

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()

image.png

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)

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}

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)

image.png

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.

Recommended Posts

Implémentation informatique quantique de Quantum Walk 2
Implémentation informatique quantique de Quantum Walk 3
Implémentation informatique quantique de Quantum Walk 1
Implémentation informatique quantique de la marche quantique à 3 états
Qiskit: Implémentation de Quantum Boltsman Machine
Qiskit: Implémentation des états d'hypergraphes quantiques
Qiskit: mise en œuvre de l'apprentissage des circuits quantiques (QCL)
Implémentation de la séquence de Fibonacci
Implémentation de TF-IDF à l'aide de gensim
Implémentation de MathJax sur Sphinx
Explication et mise en œuvre de SocialFoceModel
Mise en œuvre de la théorie des jeux - Le dilemme du prisonnier -
Mise en œuvre d'une analyse de composants indépendante
Implémentation Python du filtre à particules
Implémentation du tri rapide en Python
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Implémentation de Scale-Space pour SIFT
Lire "Principes de base du recuit quantique" Jour 5
Explication et mise en œuvre de PRML Chapitre 4
Introduction et mise en œuvre de JoCoR-Loss (CVPR2020)
Explication et implémentation de l'algorithme ESIM
Introduction et mise en œuvre de la fonction d'activation
Implémentation Python du filtre à particules auto-organisateur
Résumé de l'implémentation de base par PyTorch
Mise en place d'un filtre à particules simple
Implémentation d'un réseau de neurones à deux couches 2
Implémentation de la fonction de connexion dans Django
[Débutant] Site d'apprentissage informatique quantique [gratuit]
Implémentation Einsum de la méthode d'itération de valeur
Implémentation du jeu de vie en Python
Explication et mise en œuvre du perceptron simple
Bases de la théorie de l'information quantique: Entropie (2)
Implémentation des notifications de bureau à l'aide de Python
implémentation de c / c ++> RingBuffer (N marges)
Implémentation Python de l'arborescence de segments non récursive
Implémentation de Light CNN (Python Keras)
Qiskit: Implémentation de QAOA sans Qiskit Aqua
Implémentation du tri original en Python
Implémentation de la méthode Dyxtra par python
Lire "Les bases du recuit quantique" Jour 6
Lisez "Ordinateur Quantum fabriqué en 14 jours". Jour 5 Amélioration du puits quantique / ajout de barrières