Implémentation informatique quantique de la marche quantique à 3 états

*** 3 La mise en œuvre de la marche quantique d'état *** est résumée Jusqu'à présent, nous avons implémenté des marches quantiques de taille de cycle arbitraire par Implémentation informatique quantique 3 de marche quantique. Cependant, tous étaient des marches quantiques à deux états avec seulement deux états, 0 ou 1. Par conséquent, je voudrais envisager une marche quantique avec trois états. Comme dans le temps précédent, reportez-vous à Mise en œuvre efficace du circuit quantique des marches quantiques pour les agents de décalage des marches quantiques sur le cycle.

À propos de la marche quantique de 3 états

Une marche quantique à trois états est une marche quantique avec trois états internes. En particulier, la matrice de Grover $ 3 \ times 3 $ sélectionnée comme agoniste des pièces est appelée Grover Walk à 3 états. Pour plus de détails, reportez-vous à Quantum Walk.

La dynamique spécifique sera expliquée plus tard, mais la *** caractéristique *** du Grover Walk à trois états sur une dimension est que même si des pièces spatialement uniformes sont placées *** localisation près de l'origine ** * Et les spreads *** linéaires *** se produisent en même temps. C'est un graphique de simulation numérique au temps 500 avec le départ d'origine de Adamal Walk 1-dimensionnel à 2 états </ font> et 1-dimensionnel Grover Walk à 3 états </ font>. *** La localisation près de l'origine *** est bien comprise.

Maintenant, pour l'implémenter avec un ordinateur quantique, il doit s'agir d'un système fini, et non d'un système infini tel qu'une dimension, nous allons donc implémenter un Grover Walk à trois états sur le cycle. Développement du temps global

W=\hat{S}\hat{C}

Laisser. Puisque nous envisageons une marche de Grover à trois états, la matrice de Grover $ 3 \ times3 $ est ajoutée à l'agent de décalage $ \ hat {C} $.

\hat{C}=I\otimes C\\
\mbox{pourtant}C=\frac{2}{3}\begin{bmatrix}1&1&1\\1&1&1\\1&1&1\end{bmatrix}-I=\frac{1}{3}\begin{bmatrix}-1&2&2\\2&-1&2\\2&2&-1\end{bmatrix}

Est adopté. L'agoniste de décalage considère trois états (00,01,10) sur le cycle.

\hat{S}=\sum_{x}(|x-1\rangle\langle x|\otimes|00\rangle \langle 00|+|x\rangle\langle x|\otimes|01\rangle \langle 01|+|x+1\rangle\langle x|\otimes|10\rangle \langle 10|)

Laisser.

Si le statut est 00, emplacement-1,
Restez en place si le statut est 01
Emplacement +1 lorsque l'état est 10 Je fais.

Pensez au circuit

Si deux bits quantiques sont utilisés pour implémenter l'état 3, il y aura quatre états, 00,01,10,11. Par conséquent, l'élément d'action de pièce et l'élément d'action de décalage sont convertis dans la notation à quatre états.

Élément d'action de pièce

\hat{C}=I\otimes C\\
\mbox{pourtant}C=\begin{bmatrix}\frac{-1}{3}&\frac{2}{3}&\frac{2}{3}&0\\\frac{2}{3}&\frac{-1}{3}&\frac{2}{3}&0\\\frac{2}{3}&\frac{2}{3}&\frac{-1}{3}&0\\0&0&0&1\end{bmatrix}

Agoniste de décalage

\hat{S}=\sum_{x}(|x-1\rangle\langle x|\otimes|00\rangle \langle 00|+|x\rangle\langle x|\otimes|01\rangle \langle 01|+|x+1\rangle\langle x|\otimes|10\rangle \langle 10|+|x\rangle\langle x|\otimes |11\rangle\langle 11|)

En suivant cette voie, il est possible de créer un état indépendant 11 qui n'est pas mélangé avec d'autres états. Par conséquent, si l'état 11 n'est pas donné à l'état initial, il s'agit d'une implémentation d'une marche quantique à trois états.

Création de circuits

Matrice de Grover

Créez une matrice de Grover $ 3 \ times 3 $ à l'intérieur de la matrice $ 4 \ times 4 $. Ici, seul le résultat de l'examen des paramètres par calcul est introduit.

import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
import math

th1=3*math.pi/2
th2=(math.pi+math.acos(1/3))*2
th3=math.pi/2

q = QuantumRegister(2, 'q')

grqc = QuantumCircuit(q)
grqc.x(q[0])
grqc.x(q[1])
grqc.cu3(th3,0,0,q[0],q[1])
grqc.cu3(th2,0,0,q[1],q[0])
grqc.cu3(th1,0,0,q[0],q[1])
grqc.x(q[0])
grqc.x(q[1])

Si vous créez une porte comme celle-ci, vous obtiendrez 3 $ \ fois 3 $ de pièces Grover en 4 $ \ fois 4 $. Vérifiez ci-dessous.

from qiskit import BasicAer

#Exécuter avec le backend du simulateur unitaire
backend = BasicAer.get_backend('unitary_simulator')
job = execute(grqc, backend)
result = job.result()

# Show the results
print(result.get_unitary(grqc, decimals=3))

[[-0.333+0.j 0.667+0.j 0.667+0.j 0. +0.j] [ 0.667+0.j -0.333+0.j 0.667+0.j 0. +0.j] [ 0.667+0.j 0.667+0.j -0.333+0.j 0. +0.j] [ 0. +0.j 0. +0.j 0. +0.j 1. +0.j]]

Montage sur circuit

Considérez les registres quantiques, les registres classiques et leurs circuits quantiques.

Emplacement qbits $ \ Rightarrow q [0] q [1] $
État qbits $ \ Rightarrow qc [0] qc [1] $
Qbits de rechange $ \ Rightarrow qaf [0] $ Considérez le circuit comme. L'idée de base de l'opération $ \ pm 1 $ du lieu est basée sur Quantum Walk Quantum Computer Implementation 2.

def cccx(circ,c1,c2,c3,tg,re):
    circ.ccx(c1,c2,re)
    circ.ccx(c3,re,tg)
    circ.ccx(c1,c2,re)

Je veux utiliser la porte cccnot, donc quand je la prépare, je fais un circuit.

from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit.tools.visualization import plot_histogram
import math

q = QuantumRegister(2, 'q')
qc = QuantumRegister(2, 'qc')
qaf = QuantumRegister(1,'qaf')
c = ClassicalRegister(2, 'c')

gqc = QuantumCircuit(q,qc,qaf,c)

th1=3*math.pi/2
th2=(math.pi+math.acos(1/3))*2
th3=math.pi/2

#temps
t=1

#Définir l'état initial
gqc.x(qc[1])
gqc.barrier()
#Développement du temps
for i in range(t):
    #coin-ope
    gqc.x(qc[0])
    gqc.x(qc[1])
    gqc.cu3(th3,0,0,qc[0],qc[1])
    gqc.cu3(th2,0,0,qc[1],qc[0])
    gqc.cu3(th1,0,0,qc[0],qc[1])
    gqc.x(qc[0])
    gqc.x(qc[1])
    gqc.barrier()
    #shift-ope cycle
    gqc.x(qc[1])
    cccx(gqc,q[1],qc[0],qc[1],q[0],qaf[0])
    gqc.ccx(qc[0],qc[1],q[1])
    gqc.x(qc[1])
    gqc.x(qc[0])
    gqc.x(qc[1])
    gqc.ccx(qc[0],qc[1],q[1])
    cccx(gqc,q[1],qc[0],qc[1],q[0],qaf[0])
    gqc.x(qc[0])
    gqc.x(qc[1])
    gqc.barrier()
    
#Observation
gqc.measure(q,c)

gqc.draw()

Dans la première partie, l'état initial est créé. Cette fois

\Psi=|00\rangle\otimes|01\rangle

faire. La deuxième partie est la partie d'état *** agoniste de pièce de monnaie ***. La troisième partie exprime le *** agent de décalage *** qui "place +1 pour l'état 10, place -1 pour l'état 00 et la place ne change pas pour les états 01 et 11".

Exécutez ce qui précède dans le simulateur.

provider=IBMQ.get_provider(group='open')
backend_cs=provider.get_backend('ibmq_qasm_simulator')
job_cs = execute(gqc, backend_cs,shots=4096)
result_cs = job_cs.result()
counts_cs = result_cs.get_counts(gqc)
print(counts_cs)
plot_histogram(counts_cs)

Le résultat de cette simulation est

\hat{S}\hat{C}|00\rangle\otimes|01\rangle\\
=\hat{S}\left\{|00\rangle\otimes\frac{2}{3}|00\rangle+|00\rangle\otimes\frac{-1}{3}|01\rangle+|00\rangle\otimes\frac{2}{3}|10\rangle\right\}\\
=\frac{2}{3}|11\rangle\otimes|00\rangle+\frac{-1}{3}|00\rangle\otimes|01\rangle+\frac{2}{3}|01\rangle\otimes|10\rangle

Par conséquent, les probabilités d'observation des lieux $ 11 $, $ 00 $ et $ 01 $ sont respectivement $ \ frac {4} {9} $, $ \ frac {1} {9} $ et $ \ frac {4} {9} $. Cela devrait être le cas, pour que vous puissiez voir que la simulation a réussi.

Supplément

En augmentant le nombre d'états et en créant les éléments pièce et décalage correspondants, il est possible de mettre en œuvre une marche quantique sur n'importe quel graphe. Une marche quantique à 4 états sur le tore peut être créée par une simple application de la marche quantique à 2 états sur le cycle.

Le terme de stagnation introduit au début près de l'origine de Grover sur une dimension peut être confirmé par l'expérience sur le cycle de l'ordinateur quantique lorsqu'il est développé vers le temps 7 du cycle 16.