Freigeben über

Einführung in die Quantenprogrammiersprache Q#

Q# ist eine allgemeine, Open Source- Programmiersprache, die von Microsoft zum Schreiben von Quantenprogrammen entwickelt wurde. Q# ist im Quantum Development Kit (QDK) enthalten. Weitere Informationen finden Sie unter Einrichten des Quantum Development Kit.

Als Quantenprogrammiersprache erfüllt Q# die folgenden Anforderungen für Sprache, Compiler und Laufzeit:

  • 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 Programmqubits zu physischen Qubits, sodass derselbe Code auf verschiedenen Quantenprozessoren ausgeführt werden kann.
  • Integration von Quanten- und klassischem Computing:Q# ermöglicht die Integration von Quanten- und klassischen Berechnungen, die für die universelle Quantenberechnung unerlässlich sind.
  • Qubit-Verwaltung:Q# bietet integrierte Vorgänge und Funktionen für die Verwaltung von Qubits, einschließlich der Erstellung von Superpositionszuständen, Verschränken von Qubits und Durchführung von Quantenmessungen.
  • respektieren die Gesetze der Physik:Q# und Quantenalgorithmen müssen die Regeln der Quantenphysik einhalten. Sie können zum Beispiel den Qubit-Status in Q#nicht direkt kopieren oder darauf zugreifen.

Weitere Informationen zu den Ursprüngen von Q#finden Sie im Blogbeitrag Warum brauchen wir Q#?.

Struktur eines Q# Programms

Bevor Sie mit dem Schreiben von Q# Programmen beginnen, ist es wichtig, ihre Struktur und Komponenten zu verstehen. Betrachten Sie das folgende Q#-Programm namens Superposition, 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 Q# 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 Q#-Programm in seine Komponenten unterteilen.

Benutzer-Namespaces

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. Namespaces sind in Q# Programmen optional, was bedeutet, dass Sie ein Programm schreiben können, ohne einen Namespace zu definieren.

Beispielsweise könnte das Superposition-Programm des Beispiels auch ohne Namespace folgendermaßen 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;
}

Hinweis

Jedes Q# Programm kann nur eine namespacehaben. Wenn Sie keinen Namespace angeben, verwendet der Q# Compiler den Dateinamen als Namespace.

Einstiegspunkte

Jedes Q# Programm muss über einen Einstiegspunkt verfügen, der den Ausgangspunkt des Programms darstellt. 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.

Beispielsweise ist im Superposition-Programm der MeasureOneQubit()-Vorgang der Einstiegspunkt des Programms, da er das Attribut @EntryPoint() vor der Definition des Vorgangs aufweist.

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

Das Programm kann jedoch auch ohne das attribut @EntryPoint() geschrieben werden, indem der MeasureOneQubit() Vorgang in Main()umbenannt wird, z. B.:

// 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

Typen sind in jeder Programmiersprache unerlässlich, da sie die Daten definieren, mit denen ein Programm arbeiten kann. Q# bietet integrierte Typen, die für die meisten Sprachen verwendet werden, einschließlich Int, Double, Boolund Stringsowie Typen, die Bereiche, Arrays und Tupel definieren.

Q# bietet auch spezielle Typen für das Quantencomputing. Der typ Result stellt z. B. das Ergebnis einer Qubitmessung dar und kann zwei Werte aufweisen: Zero oder One.

Im Superposition-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);
    ...
}

Ein weiteres Beispiel für einen quantenspezifischen Typ ist der Qubit Typ, der ein Quantenbit darstellt.

Q# ermöglicht es Ihnen auch, eigene benutzerdefinierte Typen zu definieren. Weitere Informationen finden Sie unter Typdeklarationen.

Zuordnen von Qubits

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

Beispielsweise definiert das Superposition Programm ein einzelnes Qubit und speichert es in der Variablen q:

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

Sie können auch mehrere Qubits zuordnen und über deren Index auf die einzelnen Qubits 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.

Quantenvorgänge

Nach dem Zuordnen eines Qubits können Sie ihn an Vorgänge und Funktionen übergeben. Vorgänge sind die grundlegenden Bausteine 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. Im Superposition-Programm nimmt der MeasureOneQubit()-Vorgang 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. Wenn ein Qubit auf der Z-Basis vorliegt, wird es durch H in eine gleichmäßige Superposition versetzt, bei der es eine 50%-Wahrscheinlichkeit gibt, als Zero oder One gemessen zu werden.

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 ein oder mehrere Qubits in der angegebenen Pauli-Basis, die PauliX, PauliY oder PauliZ sein kann. Measure gibt einen Typ Result entweder von Zero oder One zurück.

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

Beispielsweise verwendet das Superposition-Programm den M-Vorgang:

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

Zurücksetzen von Qubits

In Q# müssen Qubits sich im $\ket{0}$ Zustand befinden, wenn sie freigegeben werden, um Fehler bei der Quantenhardware zu vermeiden. Sie können einen Qubit auf den $\ket{0}$ Zustand zurücksetzen, indem Sie den Reset Vorgang am Ende des Programms verwenden. Das Nicht-Zurücksetzen eines Qubits führt zu einem Laufzeitfehler.

// Reset a qubit.
Reset(q);

Namespaces der Standardbibliothek

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!");

Hinweis

Das Superposition-Programm hat keine import-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, 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);
}

Lernen Sie, Quantenprogramme mit Q# und Azure Quantum zu entwickeln

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, die ein Quantenprogramm bei der Entwicklung mit Q# und Azure Quantum durchläuft. Ihr Programm beginnt mit der Entwicklungsumgebung und endet mit der Übermittlung des Auftrags an echte Quantenhardware.

Diagramm, das den Workflow der Quantenprogrammierungsentwicklung zeigt.

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 unter Verwendung des Quantum Development Kit (QDK) in Q# schreiben. Informationen zu den ersten Schritten finden Sie unter "Schnellstart: Erstellen Ihres ersten Q# Programms".

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

Integrieren mit 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 nutzen, um Q#-Vorgänge aufzurufen oder Q# mit Python in Jupyter Notebooks zu integrieren. Weitere Informationen finden Sie unter Integration von Q# und Python.

Der Befehl %%qsharp

Q# Standardmäßig verwenden Programme in Jupyter-Notizbüchern das ipykernel Python-Paket. Um Code in eine Notizbuchzelle hinzuzufügen, 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 import qsharp ausführen, um %%qsharp zu aktivieren.
  • %%qsharp bezieht sich auf die Notebook-Zelle, in der es erscheint, und verändert den Zelltyp von Python zu Q#.
  • Sie können eine Python-Anweisung nicht vor oder nach %%qsharp platzieren.
  • Q# Code, der auf %%qsharp folgt, muss die Q#-Syntax einhalten. Verwenden Sie zum Beispiel // anstelle von #, um Kommentare zu kennzeichnen, und ;, um Codezeilen zu beenden.

Ressourcen schätzen

Bevor Ihr Programm auf realer Quantenhardware ausgeführt wird, müssen Sie herausfinden, ob es auf vorhandener Hardware laufen kann und wie viele Ressourcen es benötigt.

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

Nachdem Sie Ihr Programm in der Simulation getestet haben, können Sie es auf realer Quantenhardware ausführen. Wenn Sie ein Quantenprogramm in Azure Quantum ausführen, erstellen und führen Sie einen Job aus. Um einen Auftrag an die Azure Quantum-Anbieter zu übermitteln, benötigen Sie ein Azure-Konto und einen Quantenarbeitsbereich. Wenn Sie keinen Quantenarbeitsbereich haben, siehe "Erstellen eines Azure Quantum-Arbeitsbereichs".

Azure Quantum bietet einige der überzeugendsten und vielfältigsten Quantenhardware. Die aktuelle Liste der unterstützten Hardwareanbieter finden Sie unter Quantencomputing-Anbieter.

Nachdem Sie Ihren Auftrag übermittelt haben, verwaltet Azure Quantum den Auftragslebenszyklus, einschließlich Auftragsplanung, Ausführung und Überwachung. Sie können den Status Ihrer Aufgabe nachverfolgen und die Ergebnisse im Azure Quantum-Portal anzeigen.

Zugehöriger Inhalt