Erste Schritte mit Qiskit im Unterricht

Für dieses Modul "Qiskit im Klassenzimmer" müssen die Schüler eine funktionierende Python Umgebung mit den folgenden Paketen installiert haben:

• qiskit v2.1.0 oder neuer
• qiskit-ibm-runtime v0.40.1 oder neuer
• qiskit-aer v0.17.0 oder neuer
• qiskit.visualization
• numpy
• pylatexenc

Um die oben genannten Pakete einzurichten und zu installieren, lesen Sie die Anleitung Qiskit installieren. Um Jobs auf echten Quantencomputern ausführen zu können, müssen die Schüler ein Konto bei IBM Quantum® einrichten, indem sie die Schritte in der Anleitung zur Einrichtung Ihres IBM Cloud® Kontos befolgen.

Dieses Modul wurde getestet und verbrauchte 2 Sekunden QPU-Zeit auf einem Heron v2 Prozessor. Dies ist nur eine Schätzung. Ihre tatsächliche Nutzung kann davon abweichen.

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Einführung

In den Modulen von Qiskit in the Classroom haben Sie die Möglichkeit, einen Quantencomputer zu benutzen, um verschiedene Konzepte aus dem Bereich der Quanteninformatik zu erforschen, die mit der Quantenmechanik, der Informatik, der Chemie und anderen Bereichen zusammenhängen. Dieses Modul dient als Voraussetzung für die anderen Module - es führt in die Grundlagen des Quantencomputings ein und zeigt, wie man Qiskit verwendet, um Quantenschaltungen zu betreiben.

Zunächst geben wir Ihnen einen kurzen Überblick darüber, wie ein klassischer Computer funktioniert, und zeigen Ihnen dann, wie diese Konzepte an das Paradigma des Quantencomputers angepasst werden. Schließlich zeigen wir Ihnen, wie Sie diese Konzepte zusammenfügen, um Ihre erste Quantenschaltung zu bauen und auszuführen.

Klassische Computer

Sie sind wahrscheinlich mit den Grundlagen der Funktionsweise klassischer Computer vertraut, aber hier werden wir einige der wichtigsten Merkmale hervorheben, um dann einen Vergleich mit Quantencomputern anstellen zu können.

Die grundlegenden Informationseinheiten: Bits

Klassische Computer verarbeiten klassische Informationen, und die grundlegende Einheit der klassischen Information ist das Bit. Ein einziges Bit kann die Antwort auf eine "Ja/Nein"-Frage speichern. Üblicherweise werden die beiden binären Zustände eines Bits als "0" und "1" dargestellt.

Überprüfung von Binärzahlen

Durch die Kombination von Bits können Sie mehr Informationen speichern. Wenn Sie z. B. eine Zahl von 0 bis 15 speichern wollen, können Sie dies mit vier Bits auf folgende Weise tun:

Um eine Binärzahl mit $N$ Bits in eine bekannte Zahl base-10 umzuwandeln, multipliziert man im Allgemeinen das niedrigstwertige Bit (ganz rechts) mit $2^0 = 1$, das nächste Bit links mit $2^1 = 2$, dann das nächste mit $2^2 = 4$ und so weiter, bis man das höchstwertige (ganz links) erreicht, das man mit $2^{N-1}$ multipliziert.

Das bedeutet, dass $N$ Bits in einem von $2^N$ verschiedenen möglichen Zuständen sein können.

Überprüfen Sie Ihr Verständnis

Wie viele Bits werden benötigt, um die Zahl 86 darzustellen? Schreiben Sie den Bitstring, der diese Zahl binär kodiert.

• Antwort

  Denken Sie daran, dass Sie mit $N$ Bits die Zahlen $0$ bis $2^N - 1$ darstellen können. Mit sechs Bits kämen wir also auf $2^6 - 1 = 63$. Das ist nicht ganz ausreichend. Wir fügen ein weiteres Bit hinzu, um auf $2^7 - 1 = 127$ zu kommen. 86 können wir nun in 2er-Potenzen aufteilen:

  $$\begin{aligned} 86 &= 64 + 16 + 4 + 2 \\ &= 2^6 \times 1 + 2^5 \times 0 + 2^4 \times 1 + 2^3 \times 0 + 2^2 \times 1 + 2^1 \times 1 + 2^0 \times 0 \\ &= 1010110 \end{aligned}$$

Grundlegende Operationen: Gatter

Nun muss ein Computer in der Lage sein, etwas mit den Bits zu tun, um, nun ja, rechnen zu können. Binäre Gatter sind die Operationen, die die Grundbausteine für alle komplizierteren Algorithmen und Codes bilden.

Ein-Bit-Gatter:

NICHT

Wenn man nur ein Bit hat, gibt es nur eine Möglichkeit, seinen Zustand zu verändern: den Zustand von 0 auf 1 oder von 1 auf 0 umzukehren. Wir nennen dies das "NOT"-Tor. Die Wirkung dieses Gatters - und der übrigen Gatter, die wir weiter unten besprechen werden - kann in einer so genannten "Wahrheitstabelle" dargestellt werden, mit Spalten für die Eingangs- und Ausgangszustände der Qubits. Die Wahrheitstabelle für das NOT-Gatter lautet:

Mehrbit-Gatter:

UND

AND ist ein Zwei-Bit-Gatter, das zwei Eingangsbits annimmt und ein einzelnes Bit ausgibt. Er gibt 1 aus, wenn beide Eingangsbits 1 sind, und sonst 0:

ODER

OR ist ein weiteres Zwei-Bit-Gatter mit einem einzigen Ausgangsbit. Er gibt 1 aus, wenn eines der Bits 1 ist:

XOR

XOR steht für "exklusives ODER" und ist wie das ODER-Gatter, gibt aber 1 aus, wenn nur eines der Eingangsbits 1 ist. Sie gibt 0 aus, wenn sie entweder beide 1 oder beide 0 sind:

Abmessungen:

Wenn man etwas über das klassische Rechnen lernt, wird dem Prozess des Auslesens der Bits in der Regel nicht viel Aufmerksamkeit geschenkt. Das liegt daran, dass sie aus konzeptioneller Sicht nicht sehr komplex ist. Sie können die Bits jederzeit vor, während oder nach einer Berechnung messen, ohne dass das Ergebnis davon beeinflusst wird. Dies ist beim Quantencomputing nicht der Fall, wie wir weiter unten erörtern werden.

Schaltungen:

Durch die Kombination der oben genannten Gates können Sie jede beliebige Operation auf einem Computer durchführen. Nehmen wir ein einfaches Beispiel: Mit den Gattern AND und XOR können Sie die Halbaddierer-Schaltung konstruieren, die die Summe von zwei Bits berechnet. Dies wird in einem logischen Schaltplan dargestellt, in dem die Drähte die Bits darstellen und die Gatter, die auf die Bits wirken, als Symbole auf den entsprechenden Drähten gezeigt werden:

Die beiden Bits werden also kopiert und sowohl durch ein UND-Gatter als auch durch ein XOR-Gatter geleitet. Das Ergebnis des XOR-Gatters ist das "Summenbit" (S), das an der Einerstelle der Binärzahl verbleibt, und das Ergebnis des UND-Gatters ist das "Übertragsbit" (C), das den Wert der nächsthöheren Stelle der Binärzahl darstellt. Hier ist die Wahrheitstabelle:

Überprüfen Sie Ihr Verständnis

Überprüfen Sie, ob die obige Wahrheitstabelle die richtige Lösung für eine Addiererschaltung ergibt. Überprüfen Sie also für jede der vier Möglichkeiten von A und B, dass $A+B=S+2 \times C$.

• Antwort
  $$\begin{aligned} 0+0 &= 0+0 = 0 ~\checkmark \\ 0+1 &= 1+0 = 1 ~\checkmark \\ 1+0 &= 1+0 = 1 ~\checkmark \\ 1+1 &= 0+2 = 2 ~\checkmark \\ \end{aligned}$$

Quantencomputer

Bits $\rightarrow$ -Qubits

So wie Bits die grundlegenden Einheiten der klassischen Information sind, so sind Quantenbits oder "Qubits" die grundlegenden Einheiten der Quanteninformation. Wie beim klassischen Bit kann der Zustand eines Qubits entweder 0 oder 1 sein, was wir üblicherweise als $\vert 0\rangle$ und $\vert 1\rangle$ bezeichnen. Im Gegensatz zum klassischen Bit kann sich ein Quantenbit jedoch auch gleichzeitig in einer Überlagerung der beiden Zustände $\vert 0\rangle$ und $\vert 1\rangle$ befinden. Im Allgemeinen kann sich ein Qubit in einem beliebigen Zustand $\vert \psi\rangle$ der Form befinden:

wobei $c_0$ und $c_1$ komplexe Amplituden mit $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$ sind.

Die Quantenphase

Da „ $c_0$ “ und „ $c_1$ “ komplex sind, lassen sie sich jeweils als „ $c_j = \vert c_j\vert e^{i\phi_j}$ “ schreiben, wobei „ $\phi_j$ “ als Phase bezeichnet wird. Wenn wir den gesamten Zustand mit demselben globalen Phasenfaktor multiplizieren, ändert sich physikalisch nichts – dies wird als globale Phase bezeichnet und hat keine beobachtbaren Auswirkungen.

Aus diesem Grund ist es üblich, $e^{i\phi_0}$ zu "verrechnen":

$\vert \psi\rangle = \vert c_0\vert \vert 0\rangle + \vert c_1\vert e^{i\phi}\vert 1\rangle$

wobei $\phi = \phi_1-\phi_0$ die relative Phase des Quantenzustands ist, die durchaus beobachtbare Folgen hat.

Diese Phase spielt eine sehr wichtige Rolle im Quantencomputing, und Sie werden ihre verschiedenen Konsequenzen in den folgenden Modulen von Qiskit in the Classroom erkunden.

Mehrere Qubits

Während der Zustand mehrerer Bits einfach als eine Kette von 0s und 1s ausgedrückt werden könnte, ist der Zustand mehrerer Qubits aufgrund der Prinzipien der Überlagerung und Verschränkung etwas komplizierter.

Erinnern Sie sich, dass $N$ Bits in einem von $2^N$ möglichen Zuständen sein können, die von den Binärzahlen 000...000 bis 111...111 reichen. Aber aufgrund des Superpositionsprinzips können $N$ Qubits in einer Überlagerung all dieser Zustände gleichzeitig sein!

Dies kann wie folgt ausgedrückt werden

Dabei entspricht, wie im klassischen Fall, der Zustand $\vert j\rangle$ dem Zustand, in dem sich jedes Qubit in der richtigen Kombination aus 0s und 1s befindet, um die Binärzahl $j$ zu ergeben. Diese werden als „Rechenbasiszustände“ des Quantensystems bezeichnet. Beispielsweise lässt sich ein Zustand mit drei Qubits als Überlagerung seiner acht Rechenbasiszustände darstellen:

Jedes Qubit im System wird mit einem Index $0$ bis $N-1$ bezeichnet. Die Konvention ist, die Qubit-Zustände von rechts nach links zu lesen, so dass der Zustand von Qubit $0$ der ganz rechte Zustand und der Zustand von Qubit $N-1$ der ganz linke ist. Dies wird als "Little-Endian"-Notation bezeichnet und mag auf den ersten Blick widersinnig erscheinen, da wir gewohnt sind, von links nach rechts zu lesen.

Überprüfen Sie Ihr Verständnis

Auf den ersten Blick mag es kontraintuitiv erscheinen, die Qubits von rechts nach links zu ordnen, wie es in der Little-Endian-Notation der Fall ist, aber es ist eigentlich eine sehr logische Sache! Erklären Sie warum. (Erinnern Sie sich an unsere obige Diskussion über die Umwandlung von Binärzahlen in base-10 )

• Antwort

  Wenn wir die Qubits von rechts nach links anordnen, so dass Qubit 0 das am weitesten rechts stehende und Qubit N-1 das am weitesten links stehende ist, ist es logisch, Qubit $0$ mit dem niederwertigsten Bit zu verbinden, das mit $2^0$ multipliziert wird, und Qubit $N-1$ mit dem höchstwertigen Bit, das mit $2^{N-1}$ multipliziert wird.

Verschränkung

Wie bereits erwähnt, besteht eine weitere wichtige Eigenschaft von Qubits darin, dass sie miteinander verschränkt werden können. Nehmen wir ein Beispiel für einen Zwei-Qubit-Zustand, bei dem $c_0 = c_3 = \frac{1}{\sqrt{2}}$ und $c_1 = c_2 = 0$ :

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 00\rangle + \vert 11\rangle)$

Der Zustand von Qubit 0 kann also mit gleicher Wahrscheinlichkeit entweder $\vert 0\rangle$ oder $\vert 1\rangle$ sein, und dasselbe gilt für den Zustand von Qubit 1. Diese Wahrscheinlichkeiten sind jedoch nicht mehr unabhängig voneinander. Wenn wir feststellen, dass der Zustand von Qubit 0 $\vert 0\rangle$ ist, dann wissen wir, dass sich Qubit 1 auch in $\vert 0\rangle$ befinden wird. Dies gilt unabhängig davon, wie weit die beiden Bits voneinander entfernt sind, weshalb die Messung eines verschränkten Zustands manchmal auch als "spukhafte Wirkung in der Ferne" bezeichnet wird

Die Verflechtung kann auch andere Formen annehmen. Zum Beispiel, der Staat

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 01\rangle + \vert 10\rangle)$

führt jedes Mal zu entgegengesetzten Ergebnissen: Wenn ein Qubit gemessen wird $\vert 0\rangle$, wird das andere garantiert im Zustand $\vert 1\rangle$ gefunden.

Überprüfen Sie Ihr Verständnis

Ist der Staat $\vert \psi\rangle = \vert 11\rangle$ verwickelt? Gründe?

• Antwort

  Sie ist nicht verstrickt. Zwar sind die Ergebnisse immer gleich, wenn man beide Qubits misst, aber nur, weil jedes Qubit immer im Zustand $\vert 1\rangle$ fixiert ist. Das Ergebnis der Messung eines Qubits hängt eigentlich nicht vom anderen ab - beide sind einfach immer $\vert 1\rangle$.

  Im Allgemeinen kann man den Zustand eines jeden Qubits separat beschreiben und sie dann wie folgt miteinander multiplizieren:

  $\vert \psi\rangle = \vert \psi_1\rangle \vert \psi_0\rangle$

  Dann wird er als "Produktzustand" bezeichnet und ist nicht verschränkt.

Vektorschrift

Es ist oft hilfreich, Vektoren und Matrizen zu verwenden, um zu sehen, wie sich der Quantenzustand bei verschiedenen Operationen verändert. In dieser Darstellung sind unsere Quantenzustände Vektoren und unsere Quantengatter (die im nächsten Abschnitt besprochen werden) sind Matrizen, die die Vektoren transformieren.

Für ein einzelnes Qubit wird die Vektorform der Zustände wie folgt gewählt: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ Auf diese Weise kann ein beliebiger Zustand $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ geschrieben werden als $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Für einen allgemeinen $n$ -Qubit-Zustand benötigen wir einen $2^n$ -dimensionalen Vektor, dessen Basiszustände erwartungsgemäß nach aufsteigendem Binärwert geordnet sind:

Mit dieser Wahl der Vektorschreibweise im Hinterkopf können wir unsere benötigten Quantengatter, ihre Auswirkungen auf Quantenzustände und ihre Matrixformen vorstellen.

Überprüfen Sie Ihr Verständnis

Für ein Zwei-Qubit-System gibt es vier Berechnungsbasiszustände. Schreiben Sie jedes dieser Elemente sowohl in der Ket- als auch in der Vektorschreibweise auf.

• Antwort
  $$\vert 00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix}, \vert 01 \rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, \dots, \vert 10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\ 0\end{pmatrix}, \vert 11 \rangle = \begin{pmatrix}0 \\ 0 \\ 0\\ 1\end{pmatrix}$$

Gates- $\rightarrow$ -Quantengates

So wie klassische Gatter wie NOT, AND, OR und XOR kombiniert werden können, um beliebige klassische Schaltkreise zu bilden, spielen Quantengatter die gleiche Rolle in der Quanteninformatik. Da Qubits zusätzliche quantenmechanische Eigenschaften haben, sind Quantengatter entsprechend reichhaltiger. Zwar können wir ihr Handeln anhand der Zustände $|0\rangle$ und $|1\rangle$ mit einer Wahrheitstabelle beschreiben, doch wird damit nicht das ganze Bild erfasst. Für Quantengatter ist es oft natürlicher, eine Matrixdarstellung zu verwenden, da sie auch auf Überlagerungen von Basiszuständen wirken.

Im Folgenden werden die gebräuchlichsten Quantengatter vorgestellt und wie sie die Qubits, mit denen sie interagieren, umwandeln. Gegebenenfalls werden wir sie mit den bekannten klassischen Gates verbinden.

Einzelqubit-Gatter

$X$ gatter : Dies ist das Quantenäquivalent einer NOT-Operation. Seine Wahrheitstabelle sieht genauso aus wie die des klassischen NOT-Gatters:

Und die Matrixdarstellung:

$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$

In Qiskit sieht das Erstellen eines Schaltkreises mit einem $X$ Gate wie folgt aus:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

Output:

In diesem sehr einfachen Schaltplan wird das Qubit durch einen Draht dargestellt, die schwarze horizontale Linie, und das Gatter wird als Kästchen auf diesem Draht angezeigt.

Hadamard-Tor: Erzeugt einen Überlagerungszustand. Wahrheitstabelle:

Matrix-Darstellung: $H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$

Eine Schaltung mit einem Hadamard-Gatter wird wie folgt aufgebaut:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

Output:

$Z$ tor : Fügt dem Zustand $|1\rangle$ eine Phasenverschiebung von $\Delta \phi = \pi$ hinzu:

$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$

In Qiskit sieht das Erstellen eines Schaltkreises mit einem $Z$ Gate wie folgt aus:

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Output:

$T$ tor : Fügt dem Zustand $|1\rangle$ eine Phasenverschiebung von $\Delta \phi = \pi/4$ hinzu:

$T=\begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$

In Qiskit sieht das Erstellen eines Schaltkreises mit einem $T$ Gate wie folgt aus:

qc = QuantumCircuit(1)
qc.t(0)
qc.draw("mpl")

Output:

Multi-Qubit-Gatter

Zwei-Qubit-Gatter können klassischen Zwei-Bit-Gattern ähneln, allerdings mit einem wichtigen Vorbehalt: Alle Quantengatter müssen reversibel sein. In der linearen Algebra bedeutet dies, dass sie durch unitäre Matrizen dargestellt werden. Zwei Eingangsqubits entsprechen also immer zwei Ausgangsqubits, und die Operation kann im Prinzip rückgängig gemacht werden. Dies steht im Gegensatz zu den klassischen Gattern, die wir oben gesehen haben, wie z. B. UND oder ODER, bei denen Informationen verloren gehen und die irreversibel sind - bei einem Ausgang kann man den Eingang nicht eindeutig bestimmen.

CNOT-Gatter (Controlled-NOT): Die beiden Eingangsqubits werden als „Steuer-“ und „Ziel-“Qubits bezeichnet. Das Kontroll-Qubit bleibt unverändert, doch sein Zustand bestimmt, was mit dem Ziel-Qubit geschieht. Befindet sich das Steuerqubit im Zustand $\vert 1\rangle$, wird auf das Zielqubit ein „ $X$ “-Gatter angewendet; befindet sich das Steuerqubit im Zustand $\vert 0\rangle$, erfolgt keine Änderung.

Die Gate-Argumente sind in der Reihenfolge „ $CNOT(q_{control},q_{target})$ “ angeordnet, genau wie in Qiskit qc.cx(control, target). Die Reihenfolge der Bits in einem Ket folgt einer eigenen Konvention: Qiskit schreibt Zwei-Qubit-Basiszustände als „ $\vert q_1q_0\rangle$ “ dar. Sei hier $A=q_0$ der Steuerzustand und $B=q_1$ der Zielzustand, dann lautet der Ket „ $\vert BA\rangle$ “, wobei der Steuerzustand rechts steht. Weitere Informationen findest du in der Anleitung zur Bitreihenfolge.

Für die Werte der Rechenbasis $a,b\in\{0,1\}$ der Qubits $A$ und $B$ wirkt das Gatter wie folgt:

$CNOT(A,B)\vert ba\rangle = \vert (b\oplus a)\,a\rangle$

Dabei bezeichnet $\oplus$ die Addition modulo 2 (XOR). Der Steuerwert $a$ bleibt unverändert, während der Zielwert $b$ umschaltet, wenn $a=1$ gilt.

Unter Verwendung der geordneten Basis $\vert 00\rangle,\vert 01\rangle,\vert 10\rangle,\vert 11\rangle$ für $\vert BA\rangle$ lautet die Matrix, die diese Wirkung darstellt:

$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Output:

Dies ist der erste Schaltplan mit zwei Qubits, die durch die beiden Drähte dargestellt werden. Das CNOT-Gatter wird zwischen den beiden Qubits implementiert, mit $q_0$ als Steuerung und $q_1$ als Ziel.

Überprüfen Sie Ihr Verständnis

Die meisten Gatter haben in Qiskit dieselbe Matrixform wie überall sonst auch. Das CNOT-Gatter wirkt jedoch auf zwei Qubits, sodass plötzlich die Reihenfolge der Qubits zu einem Problem wird. Texte, in denen Qubits geordnet werden $\vert q_0,q_1,...\rangle$, zeigen eine andere Matrixform für ihre CNOT-Gatter. Überprüfen Sie durch explizite Matrixmultiplikation, ob die obige CNOT-Matrix die richtige Wirkung auf den Zustands $\vert 01\rangle$ hat.

• Antwort

  $CNOT\vert 01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = \vert 11\rangle$

SWAP-Gatter: Dieses Gatter vertauscht die Zustände von zwei Qubits. Wahrheitstabelle:

Die Matrix, die diese Aktion darstellt, lautet also:

$SWAP=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1\end{pmatrix}$

qc = QuantumCircuit(2)
qc.swap(0, 1)
qc.draw("mpl")

Output:

Das SWAP-Gate kann tatsächlich aus drei CNOTs aufgebaut werden. Um zu sehen, wie, können wir decompose() das Tor mit Qiskit:

qc = QuantumCircuit(2)
qc.swap(0, 1)
qc.decompose().draw("mpl")

Output:

Hier sehen wir zum ersten Mal, wie mehrere Gatter in einem Schaltplan dargestellt werden. Wir lesen sie von links nach rechts, d. h. das ganz linke Gatter wird zuerst angewendet.

Überprüfen Sie Ihr Verständnis

Überprüfen Sie, ob die obige Kombination von CNOTs zu einem SWAP-Gate führt. Sie können dies mit der Matrixmultiplikation oder einer anderen Methode tun.

• Antwort

  Mit Matrixmultiplikation:

  $\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1\end{pmatrix} = SWAP ~\checkmark$

  Verwendung einer Wahrheitstabelle, um zu sehen, wie sich die Zustände bei jedem CNOT ändern. In der letzten Spalte sollten die Zustände mit der Spalte "Ausgang" der SWAP-Wahrheitstabelle übereinstimmen:

  Eingabe	CNOT(A,B)	CNOT(B,A)	CNOT(A,B)
  $\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle \checkmark$
  $\vert 01\rangle$	$\vert 11\rangle$	$\vert 10\rangle$	$\vert 10\rangle \checkmark$
  $\vert 10\rangle$	$\vert 10\rangle$	$\vert 11\rangle$	$\vert 01\rangle \checkmark$
  $\vert 11\rangle$	$\vert 01\rangle$	$\vert 01\rangle$	$\vert 11\rangle \checkmark$

Toffoli-Gatter (oder "controlled-controlled-NOT" (CCNOT)): Dies ist ein Drei-Qubit-Gatter. Der Name "kontrolliert-kontrolliert-NOT" verrät vielleicht schon, wie es funktioniert: Es gibt zwei Kontroll-Qubits und ein Ziel-Qubit, und der Zustand des Ziel-Qubits wird nur geflippt, wenn beide Kontroll-Qubits im Zustand $\vert 1\rangle$ sind. Wir behalten die Ordnungskonvention bei, die wir beim CNOT verwendet haben:

Die Wahrheitstabelle lautet also:

Und die Matrix, die diese Aktion repräsentiert, lautet:

qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
qc.draw("mpl")

Output:

Auch das Toffoli-Gatter kann in CNOTs zerlegt werden, ebenso wie einige andere Gatter. Sie ist jedoch wesentlich komplizierter als die SWAP-Gate-Zerlegung, so dass es als optionale Übung am Ende des Moduls übrig bleibt, diese Zerlegung zu untersuchen und zu verifizieren.

Messungen

Messungen spielen bei der Quanteninformatik eine besondere Rolle - eine Rolle, für die es keine Entsprechung in der klassischen Informatik gibt. Während man beim klassischen Rechnen seine Bits zu jedem beliebigen Zeitpunkt während eines Algorithmus überprüfen kann, muss man beim Quantencomputing sehr selektiv vorgehen, wann man seine Qubits überprüft, da die Messung ihren Zustand kollabieren lässt und die Überlagerung zerstört, die den Qubits ihre Rechenkomplexität verleiht.

Insbesondere wird bei einem $N$ -Bit-Quantenzustand $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$ der Zustand bei einer Messung mit einer Wahrscheinlichkeit gleich $\vert c_i\vert ^2$ auf eine der Basisfunktionen $\vert i\rangle$ kollabieren.

Aber diese zerstörerische Wirkung einer Messung ist nicht immer ein Hindernis. Sie ist in der Tat eine Schlüsselressource in bestimmten Algorithmen und Protokollen wie der Quantenteleportation und der Quantenschlüsselverteilung.

Wenn in Qiskit eine Messung vorgenommen wird, wird sie an ein klassisches Register gesendet, wo sie als klassisches Bit gespeichert wird. Das Erstellen eines Stromkreises mit einer Messung sieht folgendermaßen aus:

qc = QuantumCircuit(
    1, 1
)  # the second number is the number of classical bits in the circuit
qc.measure(0, 0)
qc.draw("mpl")

Output:

Schaltungen

Nachdem wir nun wissen, wie Qubits, Gatter und Messungen funktionieren, wollen wir unsere eigene Quantenschaltung bauen und ausführen! Zu diesem Zweck müssen wir Ihnen einen nützlichen Arbeitsablauf namens Qiskit-Muster vorstellen.

Qiskit-Muster-Framework

Der Qiskit-Musterrahmen ist ein allgemeines Verfahren für das Herangehen an und die Lösung von Problemen mit einem Quantencomputer. Sie besteht aus vier Schritten:

1. Übertragung unseres Problems auf Quantenschaltungen und -operatoren
2. Optimierung der Schaltung für die Zielhardware
3. Ausführen auf der Zielhardware
4. Nachbearbeitung unserer Ergebnisse

Zur Veranschaulichung dieser Schritte werden wir eine Quantenversion der oben beschriebenen Halbaddierer-Schaltung implementieren.

1. Kartierung

Die klassische Addierschaltung verwendet ein XOR- und ein AND-Gatter, um die Summe bzw. den Übertrag zu berechnen. Wir können diese Gatter an den Quantenkontext anpassen, um den Quanten-Halbaddierer herzustellen. Erstens: Da Quantengatter reversibel sind, können wir die Eingaben nicht einfach überschreiben. Stattdessen führen wir zwei Hilfsqubits ein, die mit $\vert 0\rangle$ initialisiert werden, um die Summe und den Übertrag zu speichern. Unser vollständiger Quantenzustand besteht also aus den Qubits $A$ und $B$ sowie den Summen- und Übertragsqubits, die wir als $S$ und $C$ bezeichnen:

$\vert \psi\rangle = \vert C S B A\rangle$

Jetzt brauchen wir Quantengatter, die das leisten, was die XOR- und AND-Gatter in der klassischen Schaltung geleistet haben.

Summe:

Für die XOR-Verknüpfung verwenden wir zwei CNOTs, jeweils mit den Kontroll-Qubits $A$ und $B$ und dem Ziel-Qubit $S$ für beide. Wenn $A$ und $B$ unterschiedlich sind, schaltet eines der CNOT-Gatter $S$ in den Zustand $\vert 1\rangle$ um. Wenn $A$ und $B$ beide $\vert 0\rangle$ sind, passiert mit $S$ nichts und es bleibt im Zustand $\vert 0\rangle$. Wenn $A$ und $B$ beide $\vert 1\rangle$ sind, dann wird der Zustand von $S$ zweimal umgedreht, was ihn in den Zustand von $\vert 0\rangle$ zurückbringt.

Mitnehmen:

Für das Übertragsbit brauchen wir etwas, das wie ein klassisches UND-Gatter funktioniert.

Überprüfen Sie Ihr Verständnis

Schauen Sie sich die Gatter an, die wir besprochen haben, und versuchen Sie zu erraten, welches Quantengatter wir anstelle des klassischen UND-Gatters verwenden werden:

• Antwort

  Das ist das Toffoli-Tor! Denken Sie daran, dass das Toffoli-Gatter oder das kontrolliert-kontrollierte-NICHT-Gatter den Zielzustand dann und nur dann umkehrt, wenn das Kontroll-Qubit 0 UND das Kontroll-Qubit 1 beide $\vert 1\rangle$ sind. Wenn also das Ziel-Qubit im Zustand $\vert 0\rangle$ beginnt, dann hat es die gleiche Wirkung wie das UND-Gatter.

Jetzt haben wir also alle Zutaten, die wir für den Quantenschaltkreis brauchen:

# qubits: a, b, sum, carry
qc = QuantumCircuit(4)

# Choose values for A and B:
a = 0
b = 0

# Prepare A and B qubits according to selected values:
if a:
    qc.x(0)
if b:
    qc.x(1)

# XOR (sum) into qubit 2
qc.cx(0, 2)
qc.cx(1, 2)

# AND (carry) into qubit 3
qc.ccx(0, 1, 3)  # a AND b

# measure
qc.measure_all()


qc.draw("mpl")

Output:

Oben sehen Sie den Schaltplan für die Quanten-Halbaddierer-Schaltung. Wie bereits erwähnt, stehen die Drähte für die Qubits $0$ bis $3$ in der Reihenfolge von oben nach unten, und das klassische Bitregister ist der untere zweireihige Draht. Dann sehen wir von links nach rechts, wie die Gates auf jedes Qubit angewendet werden, indem wir sehen, wo die Kästchen auf den entsprechenden Drähten auftauchen. Am Ende werden die Messungen angezeigt. Die Messungen kollabieren die Qubit-Zustände in eindeutige $0$ oder $1$ Werte, und die Ergebnisse werden an ein klassisches Register gesendet.

Eine Besonderheit: Obwohl der Schaltplan von links nach rechts gezeichnet ist, muss der entsprechende Matrixausdruck von rechts nach links geschrieben werden. Das liegt daran, dass bei der Matrixmultiplikation der Operator, der dem Zustandsvektor am nächsten ist, zuerst agiert. Die obige Schaltung (ohne Berücksichtigung der Messungen) würde also beispielsweise wie folgt geschrieben werden:

2. Optimierung:

Als Nächstes müssen wir die Schaltung für den Betrieb auf der Quantenhardware optimieren. Diese Optimierung wird durch den Transpiler erreicht, der die oben gezeigte abstrakte Schaltung in Anweisungen übersetzt, die der Quantencomputer versteht. Er ordnet die oben genannten logischen Qubits realen, physischen Qubits auf dem Prozessor zu und schreibt die Gatter im Sinne seines eigenen Satzes von Gattern um, die für den Betrieb auf dem Quantencomputer optimiert wurden. Schließlich implementiert der Transpiler auch eine so genannte "Fehlerunterdrückung und -minderung", um die Auswirkungen von Fehlern auf das Ergebnis zu minimieren. Für unsere sehr einfache Schaltung ist dies nicht so wichtig, aber wenn Sie auf Ihrer Reise zum Quantencomputer mit komplizierteren Schaltungen fortfahren, werden Sie bald den Wert der Fehlerunterdrückung und -minderung erkennen. Wenn Sie mehr darüber erfahren möchten, besuchen Sie Olivia Lanes Kurs " Quantum Computing in Practice".

Zunächst werden die Pakete geladen, die für die Kommunikation mit den Quantencomputern von IBM® erforderlich sind, und ein Backend für die Ausführung ausgewählt. Wir können entweder das am wenigsten ausgelastete Backend wählen oder ein bestimmtes Backend auswählen, dessen Eigenschaften wir kennen.

Unten finden Sie einen Code, mit dem Sie Ihre Anmeldedaten bei der ersten Verwendung speichern können. Achten Sie darauf, dass Sie diese Informationen aus dem Notebook löschen, nachdem Sie es in Ihrer Umgebung gespeichert haben, damit Ihre Anmeldedaten nicht versehentlich weitergegeben werden, wenn Sie das Notebook freigeben. Weitere Anleitungen finden Sie unter Einrichten Ihres IBM Cloud Kontos und Initialisieren des Dienstes in einer nicht vertrauenswürdigen Umgebung.

# Load IBM Quantum Compute Service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load IBM Quantum Compute Service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',
# instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

Output:

ibm_fez

Nun verwenden wir den Transpiler, um die Schaltung zu optimieren. Wir können die Optimierungsstufe von 0 (keine Optimierung) bis 3 (höchste Optimierung) wählen. Um zu erfahren, was die einzelnen Stufen beinhalten, besuchen Sie den Leitfaden für die Optimierungsstufen des Set-Transpilers. Die resultierende Schaltung wird sich deutlich von der logischen Schaltung unterscheiden, die wir in unserem Mapping-Schritt erstellt haben.

# Transpile the circuit and optimize for running on the quantum computer selected
# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

qc_isa.draw("mpl")

Output:

Ein „Sampler“ ist eine Primitive, die dazu dient, mögliche Zustände, die sich aus einem Quantenschaltkreis ergeben, zu untersuchen und statistische Daten darüber zu sammeln, welche Zustände mit welcher Wahrscheinlichkeit gemessen werden könnten. Hier importieren wir den „ IBM Quantum “-Sampler:

# Load the IBM Quantum primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Wenn Sie die Ihnen zustehende Zeit auf echten Quantencomputern ausgeschöpft haben oder wenn Sie keine Internetverbindung haben, können Sie einen Simulator verwenden. Führen Sie dazu die nachstehende Zelle aus und entfernen Sie die Markierung der entsprechenden Zeile im Schritt "Ausführen".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

3. Ausführen

Nachdem wir die Schaltung vorbereitet haben, können wir sie nun auf dem Quantencomputer ausführen!

job = sampler.run([qc_isa], shots=100)
# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator
res = job.result()
counts = res[0].data.meas.get_counts()

4. Nachbearbeitung

Jetzt können wir uns die Ergebnisse ansehen! Wir zeigen ein Histogramm der 100 Proben des Schaltkreises an.

from qiskit.visualization import plot_histogram

print("counts = ", counts)
plot_histogram(counts)

Output:

counts =  {'0000': 90, '0100': 4, '1100': 3, '0010': 3}

Das obige Histogramm zeigt die Messergebnisse aller vier Qubits am Ende der Schaltung. Ein idealer Quantencomputer ohne Rauschen würde die Qubits immer mit den gleichen Werten messen, aber in der Realität führt das Rauschen dazu, dass bei einigen Durchläufen Fehler auftreten.

Überprüfen Sie Ihr Verständnis

Verwenden Sie die Bitfolge mit den meisten Zählungen als Werte für $A$, $B$, $S$ und $C$ und überprüfen Sie, ob die Quantenaddiererschaltung funktioniert.

• Antwort

  Wir müssen überprüfen, dass $A+B = S+2 \times C$. Denken Sie daran, dass die Bitstring-Reihenfolge der Little-Endian-Notation folgt, so dass sie CSBA gelesen wird.

  Aus dem obigen Histogramm ist ersichtlich, dass die Bitfolge 0000 die dominierende ist.

  $0 + 0 = 0 + 0 \times 2 = 0 ~\checkmark$

Gehen Sie zurück und ändern Sie die Werte von $A$ und $B$ in $A=1$ und $B=1$ und gehen Sie die Schritte der Qiskit-Muster erneut durch, um die Schaltung erneut zu starten. Überprüfen Sie, ob die Addierschaltung wieder funktioniert.

• Antwort

  Sie sollten ein Histogramm erhalten, bei dem die dominante Bitfolge 1011 ist:

  $1 + 1 = 0 + 1 \times 2 = 2 ~\checkmark$

Eines der zusätzlichen Merkmale des Quanten-Half-Addders gegenüber dem klassischen Half-Adder ist, dass er mit Quanteneingaben arbeiten kann. Das heißt, er kann die Qubits $A$ und $B$ "addieren", auch wenn sie sich in einem Überlagerungszustand befinden. Im Abschnitt "Herausfordernde Fragen" unten werden Sie aufgefordert, die Qubits in Superpositionen zu bringen und zu sehen, was passiert!

Fazit

Dieses Modul wurde entwickelt, um Ihnen ein solides Grundverständnis der grundlegenden Prinzipien des Quantencomputings zu vermitteln, indem es mit dem klassischen Computing verglichen wird. Wir haben uns die klassische Halbaddierer-Schaltung angesehen und dann gezeigt, wie man die Schaltung so anpasst, dass sie mit Qubits auf einem Quantencomputer funktioniert. Jetzt sind Sie bereit, die anderen Module von Qiskit im Klassenzimmer zu erkunden!

Wichtige Konzepte:

• Im Gegensatz zu klassischen Bits, die nur die Werte 0 und 1 annehmen können, können Qubits auch in Überlagerungszuständen von sowohl 0 als auch 1 sein.
• Mehrere Qubits können sich in einer Superposition über die klassisch zulässigen Bitstrings befinden, die als Rechenbasiszustände bezeichnet werden.
• Mehrere Qubits können so verschränkt werden, dass der Zustand des einen vom Zustand des anderen abhängt.
• Die Qiskit-Konvention sieht die Verwendung der Little-Endian-Notation vor, bei der das niedrigstwertige Qubit, $q_0$, ganz rechts und das höchstwertige Qubit, $q_N$, ganz links steht.
• Quantengatter sind reversible Operationen, die durch unitäre Matrizen dargestellt werden und auf die Quantenzustandsvektoren wirken. In dieser Schreibweise wirkt die dem Vektor am nächsten liegende Matrix (die am weitesten rechts liegt) zuerst.
• Messungen lassen einen Quantensuperpositionszustand in einen seiner klassisch erlaubten Zustände kollabieren, und zwar mit einer Wahrscheinlichkeit, die dem Quadrat der Amplitude des entsprechenden Basiszustands der Superposition entspricht.
• Quantenschaltungen werden häufig mit Hilfe von Quantenschaltplänen dargestellt, in denen Qubits als horizontale Drähte dargestellt werden und Quantengatter entlang dieser Drähte von links nach rechts erscheinen.
• Um einen Quantenschaltkreis auszuführen, verwenden wir die vier Schritte des Qiskit-Musterworkflows : Zuordnen, Optimieren, Ausführen, Nachbearbeiten.

Fragen

Richtig/Falsch-Fragen

1. Ein einzelnes Bit in einem klassischen Computer kann nur den Wert 0 oder 1 annehmen.

2. Verschränkung bedeutet, dass der Zustand des einen Qubits unabhängig vom Zustand des anderen ist.

3. Quantengatter sind im Allgemeinen irreversible Operationen.

4. Die Qiskit-Konvention platziert das niederwertigste Qubit, $q_0$, an die äußerste linke Position.

5. Die Messung eines Quantenzustands ergibt immer genau das gleiche Ergebnis, wenn sie viele Male wiederholt wird.

6. Das Hadamard-Gatter erzeugt Superposition in einem einzelnen Qubit.

7. Quantenschaltungen können Messoperationen enthalten, die den Überlagerungszustand in einen der klassisch zulässigen Zustände kollabieren lassen.

8. Die Anzahl der möglichen klassischen Zustände für $N$ Bits ist $2N$.

9. Die Ergebniswahrscheinlichkeiten für Quantenmessungen sind durch die quadrierten Amplituden der klassisch messbaren Basiszustände gegeben.

Kurzantwortfragen

1. Was sind die wichtigsten Unterschiede zwischen einem Bit und einem Qubit?

2. Was passiert mit einem Quantenzustand, wenn er gemessen wird?

3. Warum verwenden wir in Qiskit die Little-Endian-Notation?

4. Was sind die vier Schritte im Arbeitsablauf der Qiskit-Muster?

Fragen zur Überprüfung:

1. Im Modul haben wir den Addierer nur benutzt, um klassisch erlaubte Zustände für $A$ und $B$ zu addieren. Aber wir können auch $A$ und $B$ in Überlagerungen vorbereiten! Ändern Sie den Code, um jedes Qubit in eine gleichwertige Überlagerung von 0 und 1 zu bringen, führen Sie dann die neue Schaltung aus und erhalten Sie ein neues Histogramm. Was sehen Sie? Erklären Sie, was passiert ist.

2. Toffoli-Tor-Zerlegung. Verwenden Sie decompose() , um zu zeigen, wie das Toffoli-Gatter in Ein- und Zwei-Qubit-Gatter zerlegt wird, und überprüfen Sie dann diese Konstruktion mit Matrixmultiplikation. Denken Sie daran, dass Schaltpläne zwar von links nach rechts gelesen werden, Matrizen aber von rechts nach links auf Quantenzustände angewendet werden!