Einführung in die Quantenprogrammiersprache Q#

Q# ist eine allgemeine Open-Source-Programmiersprache für die Entwicklung und Ausführung von Quantenalgorithmen. Q# ist im Quantum Development Kit (QDK) enthalten. Weitere Informationen finden Sie unter Einrichten des Quantum Development Kit.

Erfüllt als Quantenprogrammiersprache Q# die folgenden Sprach-, Compiler- und Laufzeitanforderungen:

• Hardwareagnostisch: Qubits in Quantenalgorithmen sind nicht an eine bestimmte Quantenhardware oder ein bestimmtes Layout gebunden. Der Q# Compiler und die Laufzeit verarbeiten die Zuordnung von Programm-Qubits zu physischen Qubits.
• Integriert Quanten- und Klassisches Computing: Die Fähigkeit, klassische und Quantenberechnungen durchzuführen, ist in einem universellen Quantencomputer unerlässlich.
• Respektiert die Gesetze der Physik:Q# und Quantenalgorithmen folgen den Regeln der Quantenphysik. Sie können z. B. nicht direkt kopieren oder auf den Qubit-Zustand zugreifen.Q#

Struktur eines Q# Programms

Bevor Sie mit dem Schreiben von Quantenprogrammen beginnen, ist es wichtig, ihre Struktur und Komponenten zu verstehen. Betrachten Sie das folgende Q# Programm, das einen Superpositionszustand erstellt:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Basierend auf den Kommentaren (//), weist das Superposition Programm zuerst ein Qubit zu, wendet einen Vorgang an, um den Qubit in Superposition zu setzen, misst den Qubit-Zustand, setzt den Qubit zurück und gibt schließlich das Ergebnis zurück. Lassen Sie uns dieses Programm in seine Komponenten unterteilen.

Benutzernamespaces

Q# Programme können optional mit einem benutzerdefinierten Namespace beginnen, z. B.:

namespace Superposition {
    // Your code goes here.
}

Namespaces können Ihnen beim Organisieren verwandter Funktionen helfen. Jedes Q# Programm kann nur eine namespacehaben. Wenn kein Namespace angegeben ist, verwendet der Q# Compiler den Dateinamen als Namespace. Beispielsweise könnte das Superposition Programm wie folgt geschrieben werden:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Die Q# Standardbibliothek verfügt über vordefinierte Namespaces, die Funktionen und Vorgänge enthalten, die Sie in Quantenprogrammen verwenden können. Weitere Informationen finden Sie unter integrierten Namespaces.

Einstiegspunkte

Standardmäßig startet der Q# Compiler die Ausführung eines Programms aus dem Main() Vorgang, sofern verfügbar, das sich an einer beliebigen Stelle im Programm befinden kann. Optional können Sie das @EntryPoint() Attribut verwenden, um einen beliebigen Vorgang im Programm als Ausführungspunkt anzugeben.

Superposition Im Programm ist der beschreibende MeasureOneQubit() Vorgang der Einstiegspunkt des Programms.

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...

Das Programm kann jedoch auch ohne das @EntryPoint() Attribut geschrieben werden, indem er den MeasureOneQubit() Vorgang umbenennen in Main():

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Typen

Q# bietet integrierte Typen , die für die meisten Sprachen verwendet werden, einschließlich Int, Double, Boolund , und StringTypen, die speziell für Quantencomputing sind. Der Typ stellt z Result . B. das Ergebnis einer Qubitmessung dar und kann einen von zwei Werten aufweisen: Zero oder One.

Superposition Im Programm gibt der MeasureOneQubit() Vorgang einen Result Typ zurück, der dem Rückgabetyp des M Vorgangs entspricht. Das Messergebnis wird in einer neuen Variablen gespeichert, die mithilfe der let Anweisung definiert wird:

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...

Q# bietet auch Typen, die Bereiche, Arrays und Tupel definieren. Sie können sogar eigene benutzerdefinierte Typen definieren.

Zuordnen von Qubits

In Q#, sie weisen Qubits mithilfe des use Schlüsselworts zu. Qubits werden immer im $\ket{0}$ Zustand zugewiesen.

Das Superposition Programm definiert ein einzelnes Qubit:

// Allocate a qubit.
use q = Qubit();

Sie können auch mehrere Qubits zuordnen und über ihren Index auf die einzelnen Zuweisen zugreifen:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Weitere Informationen finden Sie unter Use-Anweisung.

Quantenvorgänge

Nach dem Zuordnen eines Qubits können Sie es an Vorgänge und Funktionen übergeben, auch als Aufrufe bezeichnet. Vorgänge sind die Grundbausteine eines Q#-Programms. Eine Q# Operation ist eine Quantenunterroutine oder eine aufrufbare Routine, die Quantenvorgänge enthält, die den Zustand des Qubit-Registers ändern.

Zum Definieren eines Q# Vorgangs geben Sie einen Namen für den Vorgang, dessen Eingaben und die Ausgabe an. Superposition Im Programm ist der MeasureOneQubit() Betrieb im Wesentlichen das gesamte Programm. Es akzeptiert keine Parameter und gibt einen Result Typ zurück:

operation MeasureOneQubit() : Result {
    ...
}

Hier ist ein einfaches Beispiel, das keine Parameter akzeptiert und keinen Rückgabewert erwartet. Der Unit Wert entspricht NULL in anderen Sprachen:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

Die Q# Standardbibliothek bietet auch Vorgänge, die Sie in Quantenprogrammen verwenden können, z. B. den Hadamard-Vorgang, Him Superposition Programm. Bei einem Qubit auf der Z-Basis H wird das Qubit in eine gleichmäßige Superposition versetzt, bei der es eine 50 %-Wahrscheinlichkeit hat, als Zero oder One.

Messen von Qubits

Während es viele Arten von Quantenmessungen gibt, Q# konzentriert sich der Schwerpunkt auf projektiven Messungen auf einzelnen Qubits, auch als Pauli-Messungen bezeichnet.

In Q#, misst der Measure Vorgang eine oder mehrere Qubits in der angegebenen Pauli-Basis, die kann PauliX, , PauliYoder PauliZ. Measure gibt einen Result Typ von entweder Zero oder One.

Um eine Messung in der Rechenbasis $\lbrace,\ket{1}\rbrace\ket{0}$ zu implementieren, können Sie auch den Vorgang verwenden, der M ein Qubit in der Pauli Z-Basis misst. Dies entspricht M Measure([PauliZ], [qubit]).

Das Superposition Programm verwendet den M Vorgang:

// Measure the qubit in the Z-basis.
let result = M(q);

Zurücksetzen von Qubits

In Q#, Qubits müssen sich $\ket{0}$ im Zustand befinden, wenn sie losgelassen werden. Verwenden Sie den Reset Vorgang, um jeden Qubit auf den $\ket{0}$ Zustand zurückzusetzen, bevor er am Ende des Programms freigegeben wird. Das Zurücksetzen eines Qubits führt zu einem Laufzeitfehler.

// Reset a qubit.
Reset(q);

Integrierte Namespaces

Die Q# Standardbibliothek verfügt über integrierte Namespaces, die Funktionen und Vorgänge enthalten, die Sie in Quantenprogrammen verwenden können. Beispielsweise enthält der Microsoft.Quantum.Intrinsic Namespace häufig verwendete Vorgänge und Funktionen, z M . B. zum Messen von Ergebnissen und Message zum Anzeigen von Benutzermeldungen an einer beliebigen Stelle im Programm.

Um eine Funktion oder einen Vorgang aufzurufen, können Sie den vollständigen Namespace angeben oder eine import Anweisung verwenden, die alle Funktionen und Vorgänge für diesen Namespace verfügbar macht und den Code besser lesbar macht. In den folgenden Beispielen wird derselbe Vorgang aufgerufen:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Das Superposition Programm hat import keine Anweisungen oder Aufrufe mit vollständigen Namespaces. Das liegt daran, dass die Q# Entwicklungsumgebung automatisch zwei Namespaces lädt: Microsoft.Quantum.Core und Microsoft.Quantum.Intrinsic, die häufig verwendete Funktionen und Vorgänge enthalten.

Sie können den Microsoft.Quantum.Measurement Namespace nutzen, indem Sie den MResetZ Vorgang verwenden, um das Superposition Programm zu optimieren. MResetZ kombiniert die Mess- und Rücksetzungsvorgänge in einem Schritt, wie im folgenden Beispiel gezeigt:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Entwickeln von Quantenprogrammen mit Q# Azure Quantum

Q# und Azure Quantum sind eine leistungsstarke Kombination für die Entwicklung und Ausführung von Quantenprogrammen. Mit Q# und Azure Quantum können Sie Quantenprogramme schreiben, ihr Verhalten simulieren, ressourcenanforderungen schätzen und auf realer Quantenhardware ausführen. Diese Integration ermöglicht es Ihnen, das Potenzial von Quantencomputing zu erkunden und innovative Lösungen für komplexe Probleme zu entwickeln. Ganz gleich, ob Sie Anfänger oder erfahrene Quantenentwickler sind, und Azure Quantum stellt die Tools und Ressourcen bereit, Q# die Sie benötigen, um die Leistungsfähigkeit von Quantum Computing zu entsperren.

Das folgende Diagramm zeigt die Phasen, durch die ein Quantenprogramm bei der Entwicklung mit Q# azure Quantum übergeben wird. Ihr Programm beginnt mit der Entwicklungsumgebung und endet mit der Übermittlung des Auftrags an echte Quantenhardware.

Lassen Sie uns die Schritte im Diagramm aufschlüsseln.

Auswählen Ihrer Entwicklungsumgebung

Führen Sie Ihre Quantenprogramme in Ihrer bevorzugten Entwicklungsumgebung aus. Sie können den Onlinecode-Editor auf der Azure Quantum-Website, die gehosteten Jupyter-Notizbücher in Ihrem Azure Quantum-Arbeitsbereich im Azure-Portal oder eine lokale Entwicklungsumgebung mit Visual Studio Code verwenden. Weitere Informationen finden Sie unter "Verschiedene Möglichkeiten zum Ausführen von Q# Programmen".

Schreiben Ihres Quantenprogramms

Sie können Quantenprogramme mit Q# dem Quantum Development Kit (QDK) schreiben. Informationen zu den ersten Schritten finden Sie unter "Schnellstart: Erstellen Ihres ersten Q# Programms".

Darüber hinaus Q#bietet der QDK Unterstützung für andere Sprachen für Quantencomputing, wie Qiskit und Cirq.

Integration in Python

Sie können selbst oder zusammen mit Python in verschiedenen IDEs verwenden Q# . Sie können beispielsweise ein Q# Projekt mit einem Python-Hostprogramm verwenden, um Vorgänge aufzurufen Q# . Sie können auch in Jupyter-Notizbücher in Python integriert werden Q# . Weitere Informationen finden Sie unter "Verschiedene Möglichkeiten zum Ausführen von Q# Programmen".

Der Befehl %%qsharp

Q# Standardmäßig verwenden Programme in Jupyter-Notizbüchern das ipykernel Python-Paket. Wenn Sie einer Notizbuchzelle Code hinzufügen möchten Q# , verwenden Sie den %%qsharp Befehl, der mit dem qsharp Python-Paket aktiviert ist, gefolgt von Ihrem Q# Code.

Beachten Sie bei der Verwendung %%qsharpFolgendes:

• Sie müssen zuerst ausgeführt import qsharp werden, um dies zu aktivieren %%qsharp.
• %%qsharp bereichs to the notebook cell in which it appears and changes the cell type from Python to Q#.
• Sie können eine Python-Anweisung nicht vor oder nach %%qsharpdem Einfügen einfügen.
• Q# code that follows %%qsharp must adhere to Q# syntax. Verwenden Sie // z. B. anstelle von # Kommentaren und ; zum Beenden von Codezeilen.

Hinweis

Azure-Notizbücher in der Azure-Portal enthalten die neuesten Versionen der qsharp Und azure-quantum Python-Pakete, sodass Sie nichts installieren müssen. Weitere Informationen finden Sie unter "Erste Schritte mit Q# und Azure Quantum-Notizbüchern".

Ressourcen schätzen

Bevor Sie auf echter Quantenhardware ausgeführt werden, müssen Sie herausfinden, ob Ihr Programm auf vorhandener Hardware ausgeführt werden kann und wie viele Ressourcen es verbrauchen wird.

Mit dem Azure Quantum Resource Estimator können Sie Architekturentscheidungen bewerten, Qubit-Technologien vergleichen und die ressourcen ermitteln, die zum Ausführen eines bestimmten Quantenalgorithmus erforderlich sind. Sie können aus vordefinierten fehlertoleranten Protokollen wählen und Annahmen des zugrunde liegenden physischen Qubit-Modells angeben.

Weitere Informationen finden Sie unter Ausführen der ersten Ressourcenschätzung.

Hinweis

Der Azure Quantum Resources Estimator ist kostenlos und erfordert kein Azure-Konto.

Ausführen Ihres Programms in der Simulation

Wenn Sie ein Quantenprogramm kompilieren und ausführen, erstellt der QDK eine Instanz des Quantensimulators und übergibt den Q# Code an ihn. Der Simulator verwendet den Q#-Code, um Qubits (Simulationen von Quantenteilchen) zu erstellen und Transformationen anzuwenden, um deren Zustand zu ändern. Danach werden die Ergebnisse der Quantenoperationen im Simulator an das Programm zurückgegeben. Durch die Isolierung des Q#-Codes im Simulator wird sichergestellt, dass die Algorithmen den Gesetzen der Quantenphysik folgen und ordnungsgemäß auf Quantencomputern ausgeführt werden können.

Übermitteln Sie Ihr Programm an echte Quantenhardware

Sie können Ihre Q# Programme (auch als Aufträge bezeichnet) über Ihre bevorzugte Entwicklungsumgebung lokal und online an Azure Quantum übermitteln. Weitere Informationen finden Sie unter Senden von Q#Aufträgen. Sie können auch Quantenschaltungen ausführen und übermitteln, die in Qiskit- und Cirq-Sprachen geschrieben wurden.

Azure Quantum bietet einige der überzeugendsten und vielfältigen Quantenhardware, die heute von Branchenführern zur Verfügung steht. Die aktuelle Liste der unterstützten Hardwareanbieter finden Sie unter Quantencomputing-Anbieter in Azure Quantum.

Hinweis

Das cloudbasierte Quantinuum H-Series-Emulatorziel ist ohne Ein Azure-Konto verfügbar. Um einen Auftrag an den Rest der Azure Quantum-Anbieter zu übermitteln, benötigen Sie ein Azure-Konto und einen Quantenarbeitsbereich. Wenn Sie keinen Quantenarbeitsbereich haben, lesen Sie " Erstellen eines Azure Quantum"-Arbeitsbereichs.

Das folgende Diagramm zeigt den grundlegenden Arbeitsablauf, nachdem Sie Ihren Auftrag übermittelt haben:

Zugehöriger Inhalt

• Verschiedene Möglichkeiten zum Ausführen von Q# Programmen
• Einrichten des Quantum Development Kit
• Schnellstart: Erstellen Ihres ersten Q# Programms