Ein Beispielquantenalgorithmus, der zur Demonstration von Sprachen nützlich ist

9

Ich suche einen Quantenalgorithmus, mit dem ich die Syntax verschiedener Quantensprachen demonstrieren kann. Meine Frage ist , ähnlich wie dies jedoch für mich, „gut“ bedeutet:

Was es tut, könnte in 1-2 Absätzen beschrieben werden und sollte leicht zu verstehen sein.
Sollte mehr Elemente der "Quantenprogrammierwelt" verwenden (ich meine, der Algorithmus sollte einige klassische Konstanten, Messungen, Bedingungen, Q-Register, Operatoren usw. verwenden, so viele wie möglich).
Der Algorithmus sollte klein sein (höchstens 15-25 Pseudocode-Zeilen lang).

Nützliche Algorithmen sind oft zu lang / zu hart, aber der Algorithmus von Deutsch verwendet nicht so viele Elemente. Kann mir jemand einen Demo-Algorithmus vorschlagen?

algorithm resource-request programming

— Klenium
quelle

Ist Ihre Anforderung auch, dass es sich um einen "Algorithmus" mit klassischer Eingabe und klassischer Ausgabe handelt und einen deutlichen Vorteil / Unterschied zu der Funktionsweise des entsprechenden klassischen Algorithmus aufweist?

— DaftWullie

@DaftWullie Diese sind nicht erforderlich. Die Parameter- oder klassische Konstanteninitialisierung eines Operators kann für mich die "Eingabe" darstellen, und ich werde bei Bedarf das Ausgabeformat bereitstellen. Es muss nichts Besonderes sein. Der Schwerpunkt liegt auf der Syntax der Sprachen. Die Beschreibung dient nur zur Überprüfung, ob die Codes in verschiedenen Sprachen gleich sind. Die Bedeutung des Algorithmus ist irrelevant.

— Klenium

Willkommen bei Quantum Computing SE! Sind Ihre Kriterien für eine gute Antwort die meisten Elemente im kürzesten Pseudocode?

— Mithrandir24601

1

@ Mithrandir24601 Danke! Ja, irgendwie so.

— Klenium

3

Ich schlage vor, Eigenwert- / Eigenvektor-Schätzprotokolle zu betrachten. Es gibt viel Flexibilität, um das Problem so einfach oder so schwer zu machen, wie Sie möchten.

Beginnen Sie mit der Auswahl von zwei Parametern, und . Sie möchten eine Qubit-Einheit entwerfen, die Eigenwerte der Form für ganze Zahlen . Stellen Sie sicher, dass mindestens einer dieser Eigenwerte eindeutig ist, und nennen Sie ihn . Stellen Sie außerdem sicher, dass ein einfacher Produktzustand, z. B. , eine Überlappung ungleich Null mit dem Eigenvektor des Eigenwerts . $n$ $k$ $n$ $U$ $e^{-2\pi iq/2^k}$ $q$ $\omega$ $|0\rangle^{\otimes n}$ $\omega$

Das Ziel wäre es, einen Phasenschätzungsalgorithmus zu implementieren, dem der Wert mitgeteilt wird und der die Aufgabe hat, einen Vektor , der der Eigenvektor ist, der dem Eigenwert . Im Allgemeinen umfasst dies eine Schaltung mit Qubits (es sei denn, Sie benötigen Ancillas, um Controlled- zu implementieren ). $k$ $|\psi\rangle$ $\omega$ $n+k$ $U$

Dies funktioniert wie folgt:

Richten Sie zwei Register ein, eines von Qubits und das andere von Qubits. ( Verwendung von Quantenregistern ) $k$ $n$

Jedes Qubit wird im Zustand initialisiert . ( Initialisierung von Quantenregistern ) $|0\rangle$

Wenden Sie einen Hadamard auf jedes Qubit im ersten Register an ( Single-Qubit-Gates ).

Wenden Sie vom Qubit im ersten Register das kontrollierte und zielen Sie auf das zweite Register ( Multi-Qubit-gesteuerte Gates ). $r$ $U^{2^{r}}$

Wenden Sie die inverse Fourier-Transformation auf das erste Register an und messen Sie jedes Qubit des ersten Registers auf der Standardbasis. Diese können kombiniert werden, um die halbklassische Fourier-Transformation zu implementieren . ( Messung und Weitergabe klassischer Daten )

Für das korrekte Messergebnis befindet sich das zweite Register im gewünschten Zustand . $|\psi\rangle$

Der Einfachheit halber könnten Sie , wählen , sodass Sie eine Einheitsmatrix mit Eigenwerten benötigen . Ich würde so etwas wie wobei das kontrollierte-NICHT bezeichnet. Es gibt nur einen Eigenvektor mit dem Eigenwert -1, nämlich , und Sie kann mit den Auswahlmöglichkeiten von und , um die Implementierung von mithilfe der Zerlegung in Bezug auf einen universellen Gate-Satz zu untersuchen (ich würde dies wahrscheinlich als vorläufiges Problem festlegen). Dann gesteuert- $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$ lässt sich einfach implementieren, indem das gesteuerte NICHT durch ein gesteuertes gesteuertes NICHT-Tor (Toffoli) ersetzt wird. Schließlich ist die inverse Fourier-Transformation nur ein Hadamard-Gate.

Für etwas komplexeres setzen Sie und ersetzen Sie durch die Quadratwurzel des Swap-Gates mit und . $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
quelle

3

Klingt so, als ob Sie ein Quantum "Hello World" wollen. Die einfachste Quantenversion davon wäre einfach, eine binär codierte Version des Textes Hello Worldin ein Register von Qubits zu schreiben . Dies würde jedoch ~ 100 Qubits erfordern und länger als Ihre Obergrenze für die Codelänge sein.

Schreiben wir also ein kürzeres Stück Text. Lassen Sie uns schreiben ;), wir brauchen eine Bitfolge der Länge 16. Insbesondere mit ASCII-Codierung

;)  =  00111011 00101001

Mit QISKit tun Sie dies mit dem folgenden Code.

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

Das ist natürlich nicht sehr quantitativ. Sie können also stattdessen zwei verschiedene Emoticons überlagern. Das einfachste Beispiel ist das Überlagern;) mit 8), da sich die Bitfolgen für diese nur bei den Qubits 8 und 9 unterscheiden.

;)  =  00111011 00101001
8)  =  00111000 00101001

So können Sie einfach die Leitungen ersetzen

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

von oben mit

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

Der Hadamard erzeugt eine Überlagerung von 0und 1, und der cnot macht es zu einer Überlagerung von 00und 11auf zwei Qubits. Dies ist die einzige erforderliche Überlagerung für ;)und 8).

Wenn Sie eine tatsächliche Implementierung sehen möchten, finden Sie diese im QISKit-Tutorial (vollständige Offenlegung: Sie wurde von mir geschrieben).

— James Wootton
quelle

Ich bekomme 404 für diesen Link. Haben Sie die Datei an einen anderen Ort verschoben?

— Klenium

Es scheint, dass das Tutorial gerade aktualisiert wurde. Ich habe den Link geändert, damit er jetzt funktioniert.

— James Wootton

1

Ich würde den (perfekten) 1-Bit-Zufallszahlengenerator vorschlagen. Es ist fast trivial einfach:

Sie beginnen mit einem einzelnen Qubit im üblichen Ausgangszustand . Dann wenden Sie das Hadamard-Gate , das die gleiche Überlagerung von und . Schließlich messen Sie dieses Qubit, um entweder 0 oder 1 mit einer Wahrscheinlichkeit von jeweils 50% zu erhalten. $\left|0\right>$ $H$ $\left|0\right>$ $\left|1\right>$

— Pyramiden
quelle