Ausführen von Hybrid-Quantencomputeraufträgen mit einem adaptiven target Profil

Hybrid Computing kombiniert klassische und Quantencomputingprozesse, um komplexe Probleme zu lösen.

Im Hybrid computing steuert der klassische Code die Ausführung von Quantenvorgängen basierend auf Mid-Circuit-Messungen, während die physischen Qubits aktiv bleiben. Sie können gängige Programmiertechniken wie geschachtelte Bedingte, Schleifen und Funktionsaufrufe in einem einzigen Quantenprogramm verwenden, um komplexe Probleme auszuführen und die Anzahl der benötigten Aufnahmen zu verringern. Mit qubit-Wiederverwendungstechniken können größere Programme auf Computern mit einer kleineren Anzahl von Qubits ausgeführt werden.

In diesem Artikel wird erläutert, wie Sie Hybridaufträge mithilfe des Adaptive RItarget Profils an Azure Quantum übermitteln. Das Adaptive RItarget Profil bietet Unterstützung für Mid-Circuit-Messungen, messbasierte Steuerungsfluss, Qubit-Rücksetzung und klassische Ganzzahlberechnung.

Voraussetzungen

• Ein Azure-Konto mit einem aktiven Abonnement. Wenn Sie nicht über ein Azure-Konto verfügen, registrieren Sie sich kostenlos, und registrieren Sie sich für ein Kostenpflichtiges Abonnement.
• Azure Quantum-Arbeitsbereich Weitere Informationen finden Sie unter Erstellen eines Azure Quantum-Arbeitsbereichs.

Wenn Sie eigenständige Programme übermitteln Q# möchten, benötigen Sie auch die folgenden Voraussetzungen:

• Visual Studio Code (VS Code) mit der installierten Azure-Erweiterung Quantum Development Kit (QDK).
• Die neueste Version der Quantum Development Kit.

Wenn Sie Python und Q# Programme übermitteln möchten, benötigen Sie auch die folgenden Voraussetzungen:

• Eine Python-Umgebung mit installiertem Python und Pip.

• Die neueste qdk Python-Bibliothek mit dem optionalen azure Zusatz.

  pip install --upgrade "qdk[azure]"
  

Unterstützung von targets

Um Hybrid-Quantencomputing-Aufträge auszuführen, müssen Sie einen Quantenanbieter auswählen, der das Adaptive RItarget Profil unterstützt.

Derzeit wird adaptives target Profil in Azure Quantum auf Quantinuumtargets unterstützt.

Übermitteln adaptiver RI-Aufträge

Um Hybrid-Quantencomputing-Aufträge zu übermitteln, müssen Sie das target Profil so Adaptive RIkonfigurieren, dass RI für "qubit Reset und Integer computations"steht.

Das Adaptive RItarget Profil bietet Unterstützung für Mid-Circuit-Messungen, messbasierte Steuerungsfluss, Qubit-Rücksetzung und klassische Ganzzahlberechnung.

Sie können Hybrid-Quantenaufträge als Q# eigenständige Programme oder Python+ Q# -Programme an Azure Quantum übermitteln. Informationen zum Konfigurieren des target Profils für hybride Quantenaufträge finden Sie in den folgenden Abschnitten.

Unterstützte Funktionen

In der folgenden Tabelle sind die unterstützten Features für hybrides Quanten computing mit Quantinuum in Azure Quantum aufgeführt.

Der QDK stellt -spezifisches Feedback bereit target, wenn Q# Sprachfeatures für die ausgewählte Option targetnicht unterstützt werden. Wenn Ihr Q# Programm nicht unterstützte Features enthält, erhalten Sie eine Fehlermeldung während der Entwurfsphase, wenn Sie hybride Quantenaufträge ausführen. Weitere Informationen finden Sie auf der QIR Wiki-Seite.

Um die unterstützten Features in Aktion anzuzeigen, kopieren Sie den folgenden Code in eine Q# Datei, und fügen Sie die nachfolgenden Codeausschnitte hinzu.

import Std.Measurement.*;
import Std.Math.*;
import Std.Convert.*;

operation Main() : Result {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);
    let r0 = MResetZ(q0);

    // Copy here the code snippets below to see the supported features 
    // in action.
    // Supported features include dynamic values, classically-bounded loops, 
    // arbitrary control flow, and mid-circuit measurement.

    r0
}

Quantinuum unterstützt dynamische Boolesche und ganze Zahlen, was bedeutet, dass Boolesche und ganze Zahlen, die von den Messergebnissen abhängen. Beachten Sie, dass r0 es sich um einen Result Typ handelt, der zum Generieren dynamischer Bool- und ganzzahliger Werte verwendet werden kann.

    let dynamicBool = r0 != Zero; 
    let dynamicBool = ResultAsBool(r0); 
    let dynamicInt = dynamicBool ? 0 | 1; 

Quantinuum unterstützt dynamische Boolesche und ganze Zahlen, unterstützt jedoch keine dynamischen Werte für andere Datentypen, z. B. Double. Kopieren Sie den folgenden Code, um Feedback zu den Einschränkungen dynamischer Werte anzuzeigen.

    let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
    let dynamicInt = r0 == One ? 1 | 0;
    let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
    let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Obwohl dynamische Werte für einige Datentypen nicht unterstützt werden, können diese Datentypen weiterhin mit statischen Werten verwendet werden.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Auch dynamische Werte unterstützter Typs können in bestimmten Situationen nicht verwendet werden. Beispielsweise unterstützt Quantinuum keine dynamischen Arrays, d. h. Arrays, deren Größe von einem Messergebnis abhängt. Quantinuum unterstützt auch keine dynamisch gebundenen Schleifen. Kopieren Sie den folgenden Code, um die Einschränkungen dynamischer Werte anzuzeigen.

    let dynamicInt = r0 == Zero ? 2 | 4;
    let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
    let staticallySizedArray = [0, size = 10];
    // Loops with a dynamic condition are not supported by Quantinuum.
    for _ in 0..dynamicInt {
         Rx(PI(), q1);
    }
        
    // Loops with a static condition are supported.
    let staticInt = 3;
    for _ in 0..staticInt {  
         Rx(PI(), q1);  
    }

Quantinuum unterstützt den Steuerungsfluss, einschließlich if/else Verzweigung, unter Verwendung statischer und dynamischer Bedingungen. Verzweigung auf dynamischen Bedingungen wird auch als Verzweigung basierend auf Messergebnissen bezeichnet.

    let dynamicInt = r0 == Zero ? 0 | 1; 
    if dynamicInt > 0 {
        X(q1);
     }
    let staticInt = 1;
    if staticInt > 5 {
         Y(q1);
    } else {
         Z(q1);
    }

Quantinuum unterstützt Schleifen mit klassischen Bedingungen und einschließlich if Ausdrücken.

    for idx in 0..3 {
        if idx % 2 == 0 {
            Rx(ArcSin(1.), q0);
            Rz(IntAsDouble(idx) * PI(), q1)
        } else {
            Ry(ArcCos(-1.), q1);
             Rz(IntAsDouble(idx) * PI(), q1)
        }
     }

Quantinuum unterstützt die Mid-Circuit-Messung, d. h. Verzweigung basierend auf Messergebnissen.

    if r0 == One {
        X(q1);
    }
    let r1 = MResetZ(q1);
    if r0 != r1 {
        let angle = PI() + PI() + PI()* Sin(PI()/2.0);
        Rxx(angle, q0, q1);
    } else {
        Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
    }

Schätzen der Kosten eines hybriden Quantencomputingauftrags

Sie können die Kosten für die Ausführung eines hybriden Quantencomputingauftrags auf Quantinuum-Hardware schätzen, indem Sie zuerst den Auftrag auf einem Emulator ausführen.

Nach erfolgreicher Ausführung im Emulator:

1. Wählen Sie in Ihrem Azure Quantum-Arbeitsbereich "Auftragsverwaltung" aus.
2. Wählen Sie den Auftrag aus, den Sie übermittelt haben.
3. Wählen Sie im Popup "Auftragsdetails " die Option "Kostenschätzung " aus, um anzuzeigen, wie viele eHQCs (Quantinuum Emulatorguthaben) verwendet wurden. Diese Zahl wird direkt in die Anzahl der HQCs (Quantinuum Quantum Credits) übersetzt, die zum Ausführen des Auftrags auf Quantinuum-Hardware erforderlich sind.

Hybride Quantencomputingbeispiele

Die folgenden Beispiele finden Sie im Q# Codebeispiel-Repository. Sie veranschaulichen den aktuellen Featuresatz für hybride Quantencomputing.

Drei-Qubit-Wiederholungscode

In diesem Beispiel wird veranschaulicht, wie Sie einen Drei-Qubit-Wiederholungscode erstellen, mit dem Bit-Flip-Fehler erkannt und korrigiert werden können.

Es nutzt integrierte Hybrid computing-Features, um zu zählen, wie oft fehlerkorrektur durchgeführt wurde, während der Zustand eines logischen Qubit-Registers kohärent ist.

Sie finden den Code in diesem Beispiel.

Iterative Phasenschätzung

Dieses Beispielprogramm veranschaulicht eine iterative Phasenschätzung innerhalb Q#von . Es verwendet iterative Phasenschätzung, um ein inneres Produkt zwischen zwei zweidimensionalen Vektoren zu berechnen, die auf einem target Qubit und einem Ancilla-Qubit codiert sind. Ein zusätzliches Steuerelement-Qubit wird auch initialisiert, was das einzige qubit ist, das für die Messung verwendet wird.

Der Schaltkreis beginnt mit der Codierung des Vektorpaars auf dem target Qubit und dem Ancilla-Qubit. Anschließend wendet er einen Oracle-Operator auf das gesamte Register an, gesteuert vom Steuer-Qubit, das im Zustand $\ket +$ eingerichtet ist. Der kontrollierte Oracle-Operator generiert eine Phase im $\ket 1$-Zustand des Kontroll qubits. Dies kann dann gelesen werden, indem ein H-Tor auf das Steuer qubit angewendet wird, um die Phase beim Messen feststellbar zu machen.

Sie finden den Code in diesem Beispiel.

Zugehöriger Inhalt

• Erste Schritte mit Sitzungen