Un exemple d'algorithme quantique, utile pour démontrer les langues

9

Je recherche un algorithme quantique que je peux utiliser pour démontrer la syntaxe de différents langages quantiques. Ma question est similaire à cela , cependant, pour moi, «bon» signifie:

Ce qu'il fait pourrait être décrit dans 1-2 paragraphes et devrait être facile à comprendre.
Devrait utiliser plus d'éléments du "monde de programmation quantique" (je veux dire que l'algorithme devrait utiliser autant de constantes classiques, mesures, conditions, qregistres, opérateurs, etc.).
L'algorithme doit être petit (au plus 15-25 pseudo-lignes de long).

Les algorithmes utiles sont souvent trop longs / difficiles, mais l'algorithme de Deutsch n'utilise pas autant d'éléments. Quelqu'un peut-il me suggérer un algorithme bon pour la démo?

algorithm resource-request programming

— klenium
source

Souhaitez-vous également qu'il s'agisse d'un «algorithme» avec une entrée et une sortie classiques, et un avantage / une différence clair par rapport à la façon dont l'algorithme classique équivalent fonctionnerait?

— DaftWullie

@DaftWullie Celles-ci ne sont pas obligatoires. L'initialisation d'un paramètre ou d'une constante classican d'un opérateur peut représenter "l'entrée" pour moi, et je fournirai le format de sortie si nécessaire. Il n'a pas besoin de faire / d'être spécial. L'accent est mis sur la syntaxe des langues, la description sert uniquement à valider que les codes dans les différentes langues sont les mêmes. La signification de l'algorithme n'est pas pertinente.

— klenium

Bienvenue sur Quantum Computing SE! Juste pour vérifier, vos critères pour une bonne réponse sont-ils le plus d'éléments dans le pseudo-code le plus court?

— Mithrandir24601

1

@ Mithrandir24601 Merci! Oui, en quelque sorte comme ça.

— klenium

3

Je suggère de regarder les protocoles d'estimation des valeurs propres / vecteurs propres. Il y a beaucoup de flexibilité pour rendre le problème aussi simple ou aussi difficile que vous le souhaitez.

Commencez par choisir deux paramètres, et . Vous voulez concevoir un unitaire à bits, qui a des valeurs propres de la forme pour les entiers . Assurez-vous qu'au moins une de ces valeurs propres est unique et appelez-la . Assurez-vous également qu'un état de produit simple, par exemple , a chevauchement non nul avec le vecteur propre de valeur propre . $n$ $k$ $n$ $U$ $e^{-2\pi iq/2^k}$ $q$ $\omega$ $|0\rangle^{\otimes n}$ $\omega$

$k$ $|\psi\rangle$ $\omega$ $n+k$ $U$

Cela fonctionne comme suit:

$k$ $n$

$|0\rangle$

appliquer un Hadamard à chaque qubit du premier registre ( portes à qubit unique )

$r$ $U^{2^{r}}$

appliquer la transformée de Fourier inverse sur le premier registre et mesurer chaque qubit du premier registre sur la base standard. Celles-ci peuvent être combinées, mettant en œuvre la transformée de Fourier semi-classique . ( mesure et rétroaction de données classiques )

$|\psi\rangle$

$n=2$ $k=1$ $4\times 4$ $\pm 1$

(U_{1} \otimes U_{2}) C (U_{1}^{†} \otimes U_{2}^{†}),

$(U_1\otimes U_2)C(U_1^\dagger\otimes U_2^\dagger),$

C

$C$

| ψ ⟩ = (U_{1} \otimes U_{2}) | 1 ⟩ \otimes (| 0 ⟩ - | 1 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$

U_{1}

$U_1$

U_{2}

$U_2$

U

$U$

U

$U$

$k=3$ $C$

(\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \end{array})

$\left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \\ \end{array} \right)$

ω = e^{\pm i π / 4}

$\omega=e^{\pm i\pi/4}$

| ψ ⟩ = (U_{1} \otimes U_{2}) (| 01 ⟩ \pm | 10 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$

— DaftWullie
source

3

On dirait que vous voulez un "Hello World" quantique. La version quantique la plus simple de cela serait simplement d'écrire une version codée binaire du texte Hello Worlddans un registre de qubits. Mais cela nécessiterait ~ 100 qubits et serait plus long que votre limite supérieure pour la longueur du code.

Écrivons donc un morceau de texte plus court. Écrivons ;), nous avons besoin d'une chaîne de bits de longueur 16. Plus précisément, en utilisant le codage ASCII

;)  =  00111011 00101001

En utilisant QISKit, vous le feriez en utilisant le code suivant.

from qiskit import QuantumProgram
import Qconfig

qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url

# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])

# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])

# second eight (qu)bits have 00111011
# these differ only on the rightmost two bits
qc.x(qr[9])
qc.x(qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])

# measure
for j in range(16):
    qc.measure(qr[j], cr[j])

# run and get results
results = qp.execute(["smiley_writer"], backend='ibmqx5', shots=1024)
stats = results.get_counts("smiley_writer")

Bien sûr, ce n'est pas très quantique. Vous pouvez donc faire une superposition de deux émoticônes différentes à la place. L'exemple le plus simple est de superposer;) avec 8), car les chaînes de bits pour celles-ci ne diffèrent que sur les qubits 8 et 9.

;)  =  00111011 00101001
8)  =  00111000 00101001

Vous pouvez donc simplement remplacer les lignes

qc.x(qr[9])
qc.x(qr[8])

de ce qui précède avec

qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot

Le Hadamard crée une superposition de 0et 1, et le cnot en fait une superposition de 00et 11sur deux qubits. Il s'agit de la seule superposition requise pour ;)et 8).

Si vous voulez voir une implémentation réelle de cela, vous pouvez le trouver sur le tutoriel QISKit (divulgation complète: il a été écrit par moi).

— James Wootton
source

J'obtiens 404 pour ce lien. Avez-vous déplacé le fichier ailleurs?

— klenium

Il semble que le tutoriel vient d'être mis à jour. J'ai changé le lien, donc ça devrait marcher maintenant.

— James Wootton

1

Je proposerais le (parfait) générateur de nombres aléatoires 1 bit. C'est presque trivialement facile:

$\left|0\right>$ $H$ $\left|0\right>$ $\left|1\right>$

— pyramides
source