Freigeben über

Schnellstart: Erstellen Ihres ersten Q# Programms

Erfahren Sie, wie Sie ein grundlegendes Q# Programm schreiben, das die Verschränkung veranschaulicht, ein Schlüsselkonzept des Quantencomputing.

Wenn zwei oder mehr Qubits verangt sind, teilen sie Quanteninformationen, was bedeutet, dass alles, was mit einem Qubit geschieht, auch mit dem anderen passiert. In diesem Schnellstart erstellen Sie einen bestimmten verschränkten Zwei-Qubit-Zustand, der als Bell-Paar bezeichnet wird. Wenn Sie in einem Bell-Paar einen Qubit im $\ket{0}$ Zustand messen, wissen Sie, dass sich das andere Qubit auch im $\ket{0}$ Zustand befindet, ohne es zu messen. Weitere Informationen finden Sie unter Quantenverschränkung.

In dieser Schnellstartanleitung führen Sie die folgenden Schritte aus:

  • Erstellen Sie die Datei Q#.
  • Weisen Sie ein Paar Qubits zu.
  • Verschränken Sie die Qubits.

Voraussetzungen

Erstellen Sie eine Q# Datei

  1. Öffnen Sie Visual Studio Code.
  2. Wählen Sie Datei>Neue Textdatei aus.
  3. Speichern Sie die Datei unter dem Namen Main.qs. Die .qs-Dateierweiterung kennzeichnet ein Q# Programm.

Schreiben Sie Ihren Q#-Code

Führen Sie in Ihrer Main.qs Datei die folgenden Schritte aus, um ein Paar Qubits zu verschränken und zu messen.

Importieren einer Quantenbibliothek

Der QDK enthält die Q# Standardbibliothek mit vordefinierten Funktionen und Operationen für Ihre Quantenprogramme. Um sie zu verwenden, müssen Sie zuerst die entsprechende Bibliothek importieren.

Verwenden Sie in Ihrem Programm eine import Anweisung, um die Std.Diagnostics Bibliothek zu öffnen. Dadurch erhalten Sie Zugriff auf alle Funktionen und Vorgänge der Bibliothek, einschließlich DumpMachine, die Sie später zum Anzeigen des verschränkten Zustands verwenden.

import Std.Diagnostics.*;

Definieren eines Vorgangs

Definieren Sie nach dem Importieren der relevanten Bibliotheken Ihren Quantenvorgang sowie ihre Eingabe- und Ausgabewerte. Für diesen Schnellstart ist Ihr Vorgang Main. Hier schreiben Sie den verbleibenden Q# Code, um zwei Qubits zuzuordnen, zu bearbeiten und zu messen.

Mainverwendet keine Parameter und gibt zwei Result Werte zurück, die ZeroOne die Ergebnisse der Qubit-Messungen darstellen:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Zwei Qubits zuordnen

Der Main Vorgang ist zurzeit leer, daher besteht der nächste Schritt darin, zwei Qubits zuzuweisen, q1 und q2. In Q# weisen Sie Qubits mit dem Schlüsselwort use zu.

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Hinweis

In Q# werden Qubits immer im $\ket{0}$ Zustand zugewiesen.

Platzieren eines Qubits in Superposition

Die Qubits q1 und q2 befinden sich im $\ket{0}$ Zustand. Um die Qubits für die Verschränkung vorzubereiten, müssen Sie eines davon in eine gleichmäßige Superposition bringen, wobei es eine 50% Wahrscheinlichkeit hat, als $\ket{0}$ oder $\ket{1}$ gemessen zu werden.

Sie setzen ein Qubit in die Superposition, indem Sie die HadamardH-Operation anwenden.

        // Put q1 into an even superposition.
        H(q1);

Der resultierende Zustand von q1 ist $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),$ die eine gleichmäßige Überlagerung von $\ket{0}$ und $\ket{{1}$.

Verangeln der Qubits

Sie sind nun bereit, die Qubits mithilfe der kontrollierten NOT-Operation, CNOT, zu verkoppeln. CNOT ist ein Steuerungsvorgang, der zwei Qubits akzeptiert, eine als Steuerelement und die andere als Ziel.

Für diesen Schnellstart legen Sie q1 als Steuer-Qubit und q2 als Ziel-Qubit fest. Dies bedeutet, dass CNOT den Zustand von q2 umschaltet, wenn der Zustand von q1$\ket{1}$ ist.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

Der resultierende Zustand beider Qubits ist das Glockenpaar $\frac{{1}{\sqrt{2}}(\ket{00}+\ket{{11}).$

Tipp

Wenn Sie erfahren möchten, wie die Hadamard- und CNOT-Operationen den Zustand der Qubits transformieren, lesen Sie Erstellen von Verschränkung mit Quantenvorgängen.

Anzeigen des verangelten Zustands

Bevor Sie die Qubits messen, ist es wichtig sicherzustellen, dass Ihr vorheriger Code sie erfolgreich verschränkt hat. Verwenden Sie den DumpMachine Vorgang, der Teil der Std.Diagnostics Bibliothek ist, um den aktuellen Status Ihres Q# Programms auszugeben:

    // Show the entangled state of the qubits.
    DumpMachine();

Messen der Qubits

Nachdem Sie nun überprüft haben, dass die Qubits verschränkt sind, können Sie die M Operation verwenden, um sie zu messen. Das Messen von q1 und q2 lässt ihre Quantenzustände in Zero oder One mit gleicher Wahrscheinlichkeit kollabieren.

In Q#, verwenden Sie das let Schlüsselwort, um eine neue Variable zu deklarieren. Um die Messergebnisse von q1 und q2 zu speichern, deklarieren Sie die Variablen m1 und m2 jeweils.

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Setze die Qubits zurück

Bevor sie am Ende jedes Q# Programms veröffentlicht werden, müssen Qubits im $\ket{0}$ Zustand sein. Dazu verwenden Sie den Reset Vorgang:

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Zurückgeben der Messergebnisse

Um den Main Vorgang abzuschließen und den verschränkten Zustand zu beobachten, geben Sie die Messergebnisse von m1 und m2 zurück.

        // Return the measurement results.
        return (m1, m2);

Tipp

Wenn Sie mehr über eine Funktion oder einen Q# Vorgang erfahren möchten, zeigen Sie darauf.

Führe deinen Q# Code aus

Herzlichen Glückwunsch! Sie haben ein Q# Programm geschrieben, das zwei Qubits verschränkt und ein Bell-Paar erstellt.

Ihr endgültiges Q# Programm sollte wie folgt aussehen:

import Std.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Wenn Sie Ihr Programm ausführen und das Ergebnis beider Qubits anzeigen möchten, wählen Sie Run oberhalb der Main-Operation aus oder drücken Sie Strg+F5.

Screenshot der Q# Datei in Visual Studio Code, der zeigt, wo der Befehl

Sie können das Programm mehrmals ausführen, jeweils mit einem anderen Ergebnis in der Debugkonsole. Dies veranschaulicht die probabilistische Natur von Quantenmessungen und die Verschränkung der Qubits.

Wenn das Ergebnis beispielsweise lautet Zero, sollte die Debugkonsole wie folgt aussehen:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Nächster Schritt

Weitere Informationen zur Quantenverschränkung finden Sie im Tutorial: Erkunden Sie die Quantenverschränkung mit Q#. Dieses Tutorial vertieft die in dieser Schnellstartanleitung behandelten Konzepte und hilft Ihnen dabei, ein umfassenderes Verschränkungsprogramm zu schreiben.

  • Last updated on