Schnellstart: Erstellen Ihres ersten Q# Programms

Artikel
10/29/2024

Erfahren Sie, wie Sie ein grundlegendes Q# Programm schreiben, das die Veranglement veranschaulicht, ein Schlüsselkonzept des Quantencomputings.

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 dieser Schnellstartanleitung erstellen Sie einen bestimmten Zwei-Qubit-verangten 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 Quantum-Veranglement.

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

Erstellen Sie die Datei Q#.
Weisen Sie ein Paar Qubits zu.
Verangeln Sie die Qubits.

Voraussetzungen

Die aktuelle Version von Visual Studio Code.
Die Azure Quantum Development Kit (QDK)-Erweiterung. Details zur Installation finden Sie unter "Einrichten des Quantum Development Kit".

Erstellen der Datei Q#

Öffnen Sie Visual Studio Code.
Wählen Sie "Neue>Textdatei speichern" aus.
Speichern Sie die Datei unter dem Namen Main.qs. Die QS-Erweiterung gibt ein Q# Programm an.

Schreiben des Q# Codes

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 Microsoft.Quantum.Diagnostics Bibliothek zu öffnen. Dadurch erhalten Sie Zugriff auf alle Funktionen und Vorgänge, einschließlich DumpMachine()derer, die Sie später zum Anzeigen des verangten Zustands verwenden.

    import Microsoft.Quantum.Diagnostics.*;

Definieren eines Vorgangs

Definieren Sie nach dem Importieren der relevanten Bibliotheken Ihren Quantenvorgang sowie ihre Eingabe- und Ausgabewerte. Für diese Schnellstartanleitung ist Mainder Vorgang . 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 OneZero die Ergebnisse der Qubit-Messungen darstellen:

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

Zuordnen von zwei Qubits

Der Main Vorgang ist zurzeit leer, daher besteht der nächste Schritt darin, zwei Qubits zuzuweisen, q1 und q2. In Q#, sie weisen Qubits mithilfe des use Schlüsselworts zu:

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

Hinweis

In Q#, Qubits werden 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 eine davon in eine gleichmäßige Oberposition setzen, wo sie eine 50% Wahrscheinlichkeit hat, als $\ket{0}$ oder $\ket{1}$.

Sie setzen ein Qubit in Die Superposition, indem Sie die Hadamard, H, Operation:

        // 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 können die Qubits jetzt mit dem kontrollierten NOT-, , CNOTOperation verkoppeln. CNOT ist ein Steuerungsvorgang, der zwei Qubits akzeptiert, eine als Steuerelement und die andere als Ziel.

Für diese Schnellstartanleitung legen Sie als Steuer-Qubit und q2 als Ziel-Qubit festq1. Dies bedeutet, dass CNOT der Zustand des Zustands kippt q2 , wenn der Zustand von q1 ist $\ket{1}$.

        // 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 das Erstellen von Veranglement mit Quantenvorgängen.

Anzeigen des verangelten Zustands

Bevor Sie die Qubits messen, ist es wichtig zu überprüfen, ob Ihr vorheriger Code sie erfolgreich verschränkt. Sie können den DumpMachine Vorgang verwenden, der Teil der Microsoft.Quantum.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, ob die Qubits verangt sind, können Sie den M Vorgang verwenden, um sie zu messen. Sie messen q1 und q2 reduzieren ihre Quantenzustände in Zero oder One mit gerader Wahrscheinlichkeit.

In Q#, verwenden Sie das let Schlüsselwort, um eine neue Variable zu deklarieren. Zum Speichern der Messergebnisse und q1 q2deklarieren Sie die Variablen m1 bzw m2.

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

Zurücksetzen der Qubits

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 verangten Zustand zu beobachten, geben Sie die Messergebnisse von m1 und m2:

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

Tipp

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

Screenshot der Details, die angezeigt werden, wenn Sie auf den Vorgang

Ausführen des Q# Codes

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

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

import Microsoft.Quantum.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 "Über dem Main Vorgang ausführen" 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 Quantenanglementierung finden Q#Sie im Lernprogramm: Erkunden Sie die Quantenanglement mit Q#. Dieses Lernprogramm erweitert die in dieser Schnellstartanleitung behandelten Konzepte und hilft Ihnen beim Schreiben eines erweiterten Veranglementprogramms.

Freigeben über