Übung – Erstellen unterschiedlicher Superpositionszustände mit Q#

  • 12 Minuten

In den vorherigen Lektionen haben Sie über Superposition und Dirac-Notation erfahren. Das ist jetzt genug Theorie! Lassen Sie uns code schreiben, um die Überlagerung in Q# zu erkunden.

In dieser Einheit erstellen Sie Quanten-Superpositionszustände in Q# und untersuchen die Rolle der Wahrscheinlichkeit bei Messergebnissen. Sie verwenden auch die DumpMachine Funktion in Q#, um zu untersuchen, wie sich der Zustand eines Systems während einer Quantenberechnung ändert.

Erstellen einer neuen Q#-Datei

  1. Öffnen Sie Visual Studio Code (VS Code).
  2. Öffnen Sie das Menü "Datei ", und wählen Sie dann " Neue Textdatei " aus, um eine neue Datei zu erstellen.
  3. Speichern Sie die Datei als "Main.qs".

Erste Schritte mit Überlagerung

Beginnen wir mit einem einfachen Q#-Programm, das ein Qubit in einem Superpositionszustand verwendet, um einen zufälligen Bitwert( 0 oder 1) zu generieren. In unserem Code verwenden wir die DumpMachine Funktion, um den Status des Qubits an verschiedenen Stellen im Programm zu sehen.

  1. Kopieren Sie den folgenden Code, und fügen Sie ihn in die Datei "Main.qs " ein:

    import Std.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

  2. Um Ihr Programm auf dem integrierten Simulator auszuführen, wählen Sie das Codeobjektiv "Ausführen" über dem Main Vorgang aus, oder drücken Sie STRG+F5. Ihre Ausgabe wird in der Debugkonsole angezeigt.

  3. Überprüfen Sie die Debugkonsole, um das Ergebnis Ihrer Messung zu finden, entweder Zero oder One.

Die DumpMachine Funktion erstellt ein Informationsverzeichnis, das den Zustand des Quantensystems beschreibt, was in diesem Fall ein einzelnes Qubit ist. Informationen aus DumpMachine umfassen die Wahrscheinlichkeitsamplitude, die Messwahrscheinlichkeit und die Phase in Bogenmaßen für jeden Basiszustand.

Ihr Code ruft die DumpMachine Funktion viermal auf:

  • Nachdem Sie das Qubit zugewiesen haben
  • Nachdem Sie das Qubit in einen Superpositionszustand versetzt haben
  • Nachdem Sie den Zustand des Qubits gemessen haben
  • Nach dem Zurücksetzen des Qubits

Sehen wir uns die Ausgabe der einzelnen Aufrufe an DumpMachine an:

  • Initialisiertes Qubit: Wenn Sie ein Qubit mit der use Anweisung zuordnen, beginnt das Qubit immer im Zustand $|0\rangle$.

    Initialized qubit:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

  • Qubit nach dem Anwenden von H: Nachdem Sie den H Vorgang angewendet haben, befindet sich der Qubit in einem gleichen Superpositionszustand, $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Qubit nach der Messung: Nachdem Sie das Qubit gemessen haben, ist das Ergebnis entweder Zero oder One, und der Qubit befindet sich vollständig im Zustand, den Sie gemessen haben.

    Qubit after the measurement:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

    Hinweis

    Ihre Ausgabe von DumpMachine nach der Messung unterscheidet sich möglicherweise von der Beispielausgabe, da Sie eine Chance von 50 % haben, jeden Zustand zu messen. Die Wahrscheinlichkeiten der Ergebnisse sind deterministisch, aber das Ergebnis einer individuellen Messung ist nicht.

  • Qubit nach dem Zurücksetzen: Der Reset Vorgang setzt den Qubit auf den Zustand $|0\rangle$ zurück, sodass er wieder für zukünftige Berechnungen verwendet werden kann.

    Qubit after resetting:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Erkunden sie andere Superpositionszustände

Nachdem Sie nun wissen, wie Sie den Zustand eines Qubit-Systems mit DumpMachineuntersuchen, untersuchen wir andere Vorgänge, die das System in verschiedene Arten von Superpositionszuständen versetzen.

Der aktuelle Zufallsbitgenerator erzeugt entweder Zero oder One mit einer Wahrscheinlichkeit von 50%. Im nächsten Beispiel sind die Wahrscheinlichkeiten nicht gleich.

Verzerrter Zufallsbitgenerator

Angenommen, Sie möchten einen zufälligen Bitgenerator erstellen, der verzerrt ist, was bedeutet, dass die Wahrscheinlichkeit, Zero zu erhalten, sich von der Wahrscheinlichkeit unterscheidet, One zu erhalten.

Sie möchten z. B. das Ergebnis Zero mit der Wahrscheinlichkeit $P$ und das Ergebnis One mit der Wahrscheinlichkeit $(1 - P)$. Folgendes ist ein gültiger Qubitzustand, der einen solchen Zufallsbitgenerator erzeugt:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1 - P}|1\rangle$$

Für diesen Zustand $|\psi\rangle$, $\alpha=\sqrt{P}$ und $\beta=\sqrt{1 - P}$ sind die Wahrscheinlichkeitsamplituden der Basiszustände $|0\rangle$ bzw. $|1\rangle$.

Um diesen Zustand zu erhalten, können Sie den Operator $R_y(2\cos^{-1}\sqrt{P})$ nacheinander auf einen Quantenbit anwenden, der im $|0\rangle$-Zustand beginnt. Um dieses Ergebnis in Q# zu erzielen, verwenden Sie die Ry aus der Standardbibliothek.

Tipp

Wenn Sie mehr über die mathematischen Operationen hinter einzelnen Qubitvorgängen erfahren möchten, arbeiten Sie das Tutorial „Single-Qubit Gates“ unter Quantum Katas durch.

Führen Sie die folgenden Schritte aus, um einen schiefen Überlagerungszustand in Q# zu erstellen:

  1. Ersetzen Sie den gesamten Code in "Main.qs" durch das folgende Beispiel, und speichern Sie die Datei. In diesem Beispiel wird $\alpha$ als ungefähr $\frac13$ ausgewählt.

    import Std.Diagnostics.*;
import Std.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. Um Ihr Programm auf dem integrierten Simulator auszuführen, wählen Sie das Codeobjektiv "Ausführen" über dem Main Vorgang aus, oder drücken Sie STRG+F5. Ihre Ausgabe wird in der Debugkonsole angezeigt.

  3. Untersuchen Sie die Ausgabe von DumpMachine und das Ergebnis Ihrer Messung. Die Ausgabe sieht in etwa wie das folgende Beispiel aus:

    The qubit is in the desired state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000

Your skewed random bit is:

One

Beachten Sie, dass die Wahrscheinlichkeit eines Zero Messergebnisses etwa 33,33% beträgt und die Wahrscheinlichkeit eines One Ergebnisses etwa 66,67%beträgt. Dieser zufällige Bitgenerator ist in Richtung One verzerrt.

Hinweis

Die Ausgabe des Messergebnisses kann sich von der Beispielausgabe unterscheiden, da der zufällige Bitgenerator probabilistisch ist. Die Wahrscheinlichkeiten der Ergebnisse sind deterministisch, aber das Ergebnis einer individuellen Messung ist nicht.

Superposition mehrerer Qubits

Bisher haben wir nur Einzel-Qubit-Systeme betrachtet. Ein guter Quantencomputer benötigt jedoch viele Qubits, um nützliche Berechnungen durchzuführen. Wie funktionieren Quantenzustände und Superposition, wenn unser System mehr als einen Qubit hat?

Betrachten Sie als Beispiel ein System von drei Qubits. Jedes Qubit kann einen Wert von 0 oder 1 aufweisen, wenn Sie sie messen, sodass es acht mögliche Zustände gibt, in denen Sie das System finden können:

$$|000\rangle,|001\rangle,|010\rangle,|011\rangle,|100\rangle,|101\rangle, |110\rangle,|111\rangle $$

Es gibt acht mögliche Zustände für dieses System, da jeder Qubit unabhängig voneinander ein 0- oder 1-Zustand sein kann, wenn wir eine Messung durchführen. Im Allgemeinen ist die Anzahl der möglichen Zustände gleich $2^n$, wobei $n$ die Anzahl der Qubits ist.

Genau wie bei einem einzelnen Qubit wird ein beliebiger Superpositionszustand für das 3-Qubit-System als gewichtete Summe dieser acht Zustände dargestellt, wobei die Gewichte die Wahrscheinlichkeitsamplitude sind:

$$|\psi\rangle=\alpha_0|000\rangle+\alpha_1|001\rangle+\alpha_2|010\rangle+\alpha_3|011\rangle+\alpha_4|100\rangle+\alpha_5|101\rangle+\alpha_6 |110\rangle+\alpha_7|111\rangle$$

Erneut sind die Amplituden $\alpha_i$ komplexe Zahlen, die die Bedingung $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$ erfüllen.

Sie können z. B. Qubits in einer einheitlichen Überlagerung platzieren, indem Sie H auf jedes Qubit anwenden. Sie können dann diese einheitliche Superposition verwenden, um einen Quanten-Zufallszahlengenerator zu erstellen, der drei Bit-Zahlen anstelle von 1-Bit-Zahlen generiert:

Basiszustand Anzahl
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Hinweis

Die Standardmethode zum Schreiben von Bitzeichenfolgen besteht darin, die kleinste Ziffer rechts und die größte Ziffer auf der linken Seite zu haben, genau wie bei normalen Dezimalzahlen. In Q# (und vielen anderen Quantenprogrammiersprachen) wird die Reihenfolge umgekehrt, sodass sich die kleinste Ziffer links befindet und die größte Ziffer rechts ist. Da die DumpMachine Funktion Quantenzustände in der Standardreihenfolge anzeigt, werden die Dezimalzahlen, denen die Zustände entsprechen, nicht sequenziell von 0 bis $n-1$ sortiert.

Führen Sie die folgenden Schritte aus, um diese Art von Zufallszahlengenerator zu erstellen:

  1. Ersetzen Sie den Code in "Main.qs" durch das folgende Beispiel, und speichern Sie dann die Datei:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. Um Ihr Programm auf dem integrierten Simulator auszuführen, wählen Sie das Codeobjektiv "Ausführen" über dem Main Vorgang aus, oder drücken Sie STRG+F5. Ihre Ausgabe wird in der Debugkonsole angezeigt.

  3. Untersuchen Sie die Ausgabe von DumpMachine und das Ergebnis Ihrer Messung. Die Ausgabe sieht in etwa wie das folgende Beispiel aus:

    The qubit register in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |011⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

6

    Hinweis

    Ihre Ausgabe hat wahrscheinlich ein anderes Ergebnis als die Beispielausgabe, da der Zufallszahlengenerator probabilistisch ist. Die Wahrscheinlichkeiten der Ergebnisse sind deterministisch, aber das Ergebnis einer individuellen Messung ist nicht.

Um mit mehreren Qubits zu arbeiten, hat Ihr Q#-Code die folgenden Änderungen:

  • Die Variable qubits repräsentiert jetzt ein Qubit-Array mit der Länge 3.
  • Die Vorgänge ApplyToEach und MeasureEachZ wenden Quantenvorgänge auf mehrere Qubits mit nur einer Codezeile an. Die Q#-Bibliotheken bieten viele Funktionen und Vorgänge, die die Quantenprogrammierung für Sie vereinfachen.
  • Die Funktion ResultArrayAsInt aus der Std.Convert Bibliothek wandelt das binäre Result Array in eine dezimale ganze Zahl um.

Die Ausgabe von DumpMachine zeigt, dass der Akt der Messung den Superpositionszustand in einen der acht möglichen Basiszustände reduziert, genauso wie bei einem einzelnen Qubit. Wenn Sie beispielsweise das Ergebnis 6erhalten, bedeutet dies, dass der Zustand des Systems auf $|011\rangle$ reduziert wurde.

Sehen wir uns nun genauer an, wie sich das System ändert, während wir jeden Qubit messen. Im vorherigen Code wird der MeasureEachZ Vorgang verwendet, um alle drei Qubits gleichzeitig zu messen. Verwenden wir stattdessen eine for Schleife, um die Qubits einzeln zu messen und mit DumpMachine den Zustand des Systems nach jeder Messung anzuzeigen.

  1. Ersetzen Sie den Code in "Main.qs" durch das folgende Beispiel, und speichern Sie dann die Datei:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register is in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        results += [M(q)];
        DumpMachine();
    }
    ResetAll(qubits);
    Message("Your random number is: ");
    return ResultArrayAsInt(results);
}

  2. Um Ihr Programm auf dem integrierten Simulator auszuführen, wählen Sie das Codeobjektiv "Ausführen" über dem Main Vorgang aus, oder drücken Sie STRG+F5. Ihre Ausgabe wird in der Debugkonsole angezeigt.

  3. Untersuchen Sie die Ausgabe von DumpMachine und das Ergebnis Ihrer Messung.

Die Ausgabe zeigt, wie jede aufeinander folgende Messung den Quantenzustand ändert und somit die Wahrscheinlichkeit, jedes Ergebnis zu erhalten. Lassen Sie uns beispielsweise jeden Teil der Ausgabe untersuchen, wenn Ihr Ergebnis lautet 5:

  • Zustandsvorbereitung: Das System befindet sich in einem gleichen Superpositionszustand, nachdem Sie auf jedes Qubit angewendet H haben.

    The qubit register is in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

  • Erste Messung: Das Ergebnis ist One für die erste Messung, daher können die einzigen möglichen Zustände, in denen sich das System befinden kann, nur die Zustände sein, bei denen das äußerste linke Bit 1 ist. Die Amplituden der Zustände, in denen der äußerst linke Qubit 0 ist, sind verschwunden, und die Wahrscheinlichkeiten der verbleibenden möglichen Zustände steigen von 12,5% auf 25,0%, sodass die Summe der Wahrscheinlichkeiten 100%bleibt.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • Zweite Messung: Das Ergebnis ist Zero für die zweite Messung, daher sind jetzt die einzigen möglichen Zustände, in denen das System enden kann, die Zustände, bei denen die beiden äußersten linken Bits 10 sind. Nun sind wir nur mit zwei möglichen Ergebnissen übrig, wenn wir das dritte Qubit messen, mit einer Wahrscheinlichkeit von 50% für jedes Ergebnis.Now're left with two possible outcome when we measure the third qubit, with a wahrscheinlichy of 50% for each outcome.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Dritte Messung: Im dritten Maß ist Onedas Ergebnis . Das System ist vollständig gemessen, und daher nicht mehr in einem Superpositionszustand, wie erwartet.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |101⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Your random number is: 

5

Mit Q# können Sie ein System von Qubits erstellen, die Qubits in einen Superpositionszustand versetzen und untersuchen, wie sich das System ändert, während Sie Quantenvorgänge anwenden oder Messungen durchführen.