Integriertes Hybridcomputing

Artikel
01/13/2024

Das integrierte Hybridcomputing vereint die klassischen und quantenbasierten Prozesse, sodass klassischer Code die Ausführung von Quantenvorgängen basierend auf Mittelkreismessungen steuern kann, während die physischen Qubits am Leben bleiben. Mithilfe gängiger Programmiertechniken wie geschachtelte Bedingungen, Schleifen und Funktionsaufrufe kann ein einzelnes Quantenprogramm komplexe Probleme ausführen, wodurch die Anzahl der erforderlichen Aufnahmen verringert wird. Mithilfe von Qubit-Wiederverwendungstechniken können größere Programme auf Computern ausgeführt werden, die eine kleinere Anzahl von Qubits verwenden.

Wichtig

Integriertes hybrides Quantencomputing wird derzeit nicht von der Erweiterung Modern Quantum Development Kit (Modern QDK) für Visual Studio Code unterstützt, zusammen mit anderen Komponenten in den Beispielen auf dieser Seite, z. B. dem I-KernelQ# , dem %azure magic-Befehl oder dem qsharp.azure Modul. Um integrierte Hybridaufträge auszuführen, verwenden Sie microsoft Quantum Development Kit (klassisches QDK). Weitere Informationen finden Sie unter Weiterarbeiten im klassischen QDK.

Weitere Informationen finden Sie unter:

Integriertes hybrides Quantencomputing

Unterstützung von targets

Derzeit wird das integrierte Hybrid Computing-Modell in Azure Quantum in Quantinuumtargets unterstützt.

Quantinuum

Unterstützte Funktion	Hinweise
Klassische Schleifen	Nur begrenzte Schleifen
Beliebiger Steuerungsfluss	Verwendung von if/else-Verzweigung
Mittelkreismessung	Verwendet klassische Registerressourcen
Qubit-Wiederverwendung	–
Klassisches Compute in Echtzeit	32-Bit-Arithmetik ohne Vorzeichen Verwendet klassische Registerressourcen

Erste Schritte

Um mit der integrierten Hybridprogrammierung zu beginnen, empfehlen wir Ihnen, die Beispiele in diesem Artikel durchzugehen oder die Registerkarte Hybrid Quantum Computing im Katalog Beispiele des Azure Quantum-Portals zu erkunden.

Übermitteln integrierter Hybridaufträge

Wenn Sie einen integrierten Hybridauftrag übermitteln, müssen Sie einen target Funktionsparameter hinzufügen, nachdem Sie angegeben haben target. Darüber hinaus werden integrierte Hybridprogramme in Azure Quantum genauso wie normale Quantenaufträge ausgeführt und verwaltet. Jeder Auftrag verfügt über eine einzelne Auftrags-ID, und das Ergebnis ist ein einzelnes Histogramm.

Wichtig

IchQ#

Wenn Sie den I-KernelQ# in einem Jupyter Notebook verwenden, verwenden Sie %azure.targetMagic-Befehl -capability mit dem AdaptiveExecution Parameter.

%azure.target quantinuum.sim.h1-1e
%azure.target-capability AdaptiveExecution

Python + Q#

Verwenden Sie bei Verwendung des Python-Pakets qsharp die qsharp.azure.target_capability Funktion mit dem AdaptiveExecution -Parameter.

qsharp.azure.target("quantinuum.sim.h1-1e")
qsharp.azure.target_capability("AdaptiveExecution")

Azure CLI

Wenn Sie die Azure CLI zum Übermitteln eines Auftrags verwenden, fügen Sie den --target-capability Parameter mit dem Wert AdaptiveExecutionhinzu.

az quantum job submit \
    --target-capability AdaptiveExecution \
    --target-id quantinuum.sim.h1-1e \
    --job-name IterativePhaseEstimation \
    --shots 100 \
    --output table

Übermitteln integrierter Hybridaufträge innerhalb einer Sitzung

Sie können mehrere integrierte Hybridaufträge in einer Sitzung mit Q# und Python kombinieren. Fügen Sie beim Übermitteln einer Sitzung den targetCapability Eingabeparameter mit dem Wert AdaptiveExecutionhinzu.

with target.open_session(name="Q# session") as session:
    target.submit(input_data=QuantumOperation, name="Job 1", input_params={"count":100, "targetCapability":"AdaptiveExecution"}) # First job submission
    target.submit(input_data=QuantumOperation, name="Job 2", input_params={"count":200, "targetCapability":"AdaptiveExecution"}) # Second job submission
    target.submit(input_data=QuantumOperation, name="Job 3", input_params={"count":300, "targetCapability":"AdaptiveExecution"}) # Third job submission

Weitere Informationen finden Sie unter Erste Schritte mit Sitzungen.

Hinweis

Obwohl Sitzungen für alle Anbieter von Quantencomputing-Hardware verfügbar sind, beachten Sie, dass integrierte hybride Quantencomputing-Aufträge derzeit in Quantinuum targetsunterstützt werden.

Schätzen der Kosten eines integrierten Hybridauftrags

Sie können die Kosten für die Ausführung eines integrierten Hybridauftrags auf Quantinuum-Hardware schätzen, indem Sie ihn zuerst auf einem Emulator ausführen.

Nach erfolgreicher Ausführung auf dem Emulator:

Wählen Sie in Ihrem Azure Quantum-Arbeitsbereich Die Option Auftragsverwaltung aus.
Wählen Sie den von Ihnen übermittelten Auftrag aus.
Wählen Sie im Popup Auftragsdetailsdie Option Kostenschätzung aus, um anzuzeigen, wie viele eHQCs (Quantinuum-Emulatorguthaben) verwendet wurden. Diese Zahl entspricht direkt der Anzahl der HQCs (Quantinuum Quantum Credits), die zum Ausführen des Auftrags auf Quantinuum-Hardware benötigt werden.

Kostenschätzung

Hinweis

Quantinuum entrollt die gesamte Leitung und berechnet die Kosten für alle Codepfade, unabhängig davon, ob sie bedingt ausgeführt werden oder nicht.

Integrierte Hybridbeispiele

Die folgenden Beispiele veranschaulichen den aktuellen Featuresatz für integriertes Hybrid Computing.

Überprüfen eines verschränkten GHZ-Zustands
Drei-Qubit-Wiederholung
Iterative Phasenschätzung

Voraussetzungen

Wenn Sie noch nicht mit Azure Quantum vertraut sind, benötigen Sie ein Azure-Abonnement und einen Azure Quantum-Arbeitsbereich, um die Beispiele auf Quantenhardware auszuführen. Weitere Informationen finden Sie unter Erstellen eines Azure Quantum-Arbeitsbereichs.
VS Code und die Quantum Development Kit Einrichtung in Ihrer lokalen Umgebung. Weitere Informationen finden Sie unter Einrichten von Quantum Development Kit.
Stellen Sie sicher, dass VS Code über die Quantum Development Kit neueste Version (0.27.258160) verfügt.
- Wählen Sie in VS Code STRG + UMSCHALT + X aus, und suchen Sie nach "Microsoft Quantum Development Kit".

Die Beispiele in diesem Artikel sind für die Ausführung in Visual Studio (VS) Code eingerichtet und verwenden die integrierte Azure-Befehlszeilenschnittstelle (CLI), um den Auftrag an Azure Quantum zu übermitteln. Um die Jupyter Notebook Version dieser und anderer Beispiele auszuführen, melden Sie sich bei Ihrem Azure-Portal Arbeitsbereich an, und zeigen Sie die Beispiele auf der Registerkarte Hybrid Quantum Computing im Katalog Beispiele an. Sie können das Notebook entweder in der Cloud ausführen oder herunterladen und lokal ausführen.

Informationen zur Problembehandlung bei integrierten Hybridprogrammen finden Sie unter Problembehandlung für integrierte Hybridprogramme.

In diesem Beispiel erfahren Sie, wie Sie klassische und Quantenanweisungen im selben Programm kombinieren, die alle vollständig vom Quantencomputing-Back-End verarbeitet werden.

Zu beachtende Features für dieses Beispiel:

Die Schleifen- und Qubitmessungen erfolgen, während die Qubits kohärent bleiben.
Die Routine kombiniert klassische und Quantencomputingvorgänge.
Sie müssen nicht lernen, für spezialisierte Hochleistungshardware zu programmieren, die neben der QPU (z. B. FPGAs) ausgeführt wird.
Das Ausführen eines entsprechenden Programms ohne die integrierten Hybridfeatures erfordert, dass jedes zwischengeschaltete Messergebnis zurückgegeben und dann die Nachverarbeitung der Daten ausgeführt werden muss.

Erstellen eines VS Code-Projekts

Erstellen Sie in VS Code ein neues Q# eigenständiges Konsolenanwendungsprojekt namens CheckGHZ.
1. Wählen Sie Befehlspalette >Q#anzeigen>: Erstellen einer neuen eigenständigen Projektkonsolenanwendung >

Ersetzen Sie die Konfiguration in CheckGHZ.csproj durch Folgendes:

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>
</Project>

Ersetzen Sie den Code in Program.qs durch Folgendes:

namespace Microsoft.Quantum.Samples {

    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Intrinsic;

    /// # Summary
    /// Counts the number of times measurements of a prepared GHZ state did not match the expected correlations.
    @EntryPoint() // The EntryPoint attribute is used to mark that this operation is where a quantum program will start running.
    operation CheckGHZ() : Int {
        use q = Qubit[3];
        mutable mismatch = 0;
        for _ in 1..10 {
            // Prepare the GHZ state.
            H(q[0]);
            CNOT(q[0], q[1]);
            CNOT(q[1], q[2]);

            // Measures and resets the 3 qubits
            let (r0, r1, r2) = (MResetZ(q[0]), MResetZ(q[1]), MResetZ(q[2]));

            // Adjusts classical value based on qubit measurement results
            if not (r0 == r1 and r1 == r2) {
                set mismatch += 1;
            }
        }
        return mismatch;
    }
}

Stellen Sie über ein Terminalfenster in VS Code eine Verbindung mit Ihrem Azure Quantum-Arbeitsbereich her, und legen Sie die Standardressourcen fest.
```
az login
```
Hinweis

Ihre Azure-Abonnement-ID, Ihre Ressourcengruppe und Ihr Arbeitsbereichsname können im Terminalfenster aufgeführt werden, nachdem Sie sich angemeldet haben, indem Sie az quantum workspace list ausführen. Alternativ finden Sie sie im Azure-Portal auf der Seite Übersicht Ihres Azure Quantum-Arbeitsbereichs.
```
az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
```

Übermitteln Sie den Auftrag, und zeigen Sie die Ergebnisse an. Bei dieser Ausführung werden ca. 10,65 eHQCs (Quantinuum-Emulator-Abrechnungseinheiten) verwendet.

az quantum job submit \
  --target-id quantinuum.sim.h1-1e \
  --job-name CheckGHZ \
  --target-capability AdaptiveExecution \
  --shots 50

az quantum job output \
  -o table \
  --job-id [job-id]

GHZ-Ausgang

In diesem Beispiel wird veranschaulicht, wie Sie einen 3-Qubit-Wiederholungscode erstellen, der zum Erkennen und Korrigieren von Bit-Flipfehlern verwendet werden kann.

Es nutzt integrierte Hybrid Computing-Features, um die Anzahl der Fehlerkorrekturen zu zählen, während der Zustand eines logischen Qubit-Registers kohärent ist.

Erstellen eines VS Code-Projekts

Erstellen Sie in VS Code ein neues Q# eigenständiges Konsolenanwendungsprojekt namens ThreeQubit.
1. Wählen Sie Befehlspalette >Q#anzeigen>: Erstellen einer neuen eigenständigen Projektkonsolenanwendung >

Ersetzen Sie die Konfiguration in ThreeQubit.csproj durch Folgendes:

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>

</Project>

Ersetzen Sie den Code in Program.qs durch Folgendes:

namespace Microsoft.Quantum.Samples {

    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation ThreeQubitRepetitionCode() : (Bool, Int) {
        // Use two qubit registers, one for encoding and an auxiliary one for syndrome measurements.
        use encodedRegister = Qubit[3];
        use auxiliaryRegister = Qubit[2];

        // Initialize the first qubit in the register to a |-〉 state.
        H(encodedRegister[0]);
        Z(encodedRegister[0]);

        // Apply several unitary operations to the encoded qubits performing bit flip detection and correction between
        // each application.
        mutable bitFlipCount = 0;
        within {
            // The 3 qubit register is used as a repetition code.
            Encode(encodedRegister);
        }
        apply {
            let iterations = 5;
            for _ in 1 .. iterations {
                // Apply a sequence of rotations to the encoded register that effectively perform an identity operation.
                ApplyRotationalIdentity(encodedRegister);

                // Measure the bit flip error syndrome, revert the bit flip if needed, and increase the count if a bit flip occurred.
                let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister, auxiliaryRegister);
                let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);
                if (bitFlipReverted) {
                    set bitFlipCount += 1;
                }
            }
        }

        // Transform the qubit to the |1〉 state and measure it in the computational basis.
        H(encodedRegister[0]);
        let result = MResetZ(encodedRegister[0]) == One;
        ResetAll(encodedRegister);

        // The output of the program is a boolean-integer tuple where the boolean represents whether the qubit
        // measurement result was the expected one and the integer represents the number of times bit flips occurred
        // throughout the program.
        return (result, bitFlipCount);
    }

    operation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj
    {
        // This operation implements an identity operation using rotations about the x-axis.
        // The Rx operation has a period of $2\pi$ (given that it is not possible to measure the difference between
        // states $|\\psi〉$ and $-|\\psi〉$). Using it to apply 4 $\frac{\pi}{2}$ rotations about the x-axis, effectively
        // leaves the qubit register in its original state.
        let theta = PI() * 0.5;
        for i in 1 .. 4 {
            for qubit in register
            {
                Rx(theta, qubit);
            }
        }
    }

    operation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool
    {
        if (parity01 == One and parity12 == Zero) {
            X(register[0]);
        }
        elif (parity01 == One and parity12 == One) {
            X(register[1]);
        }
        elif (parity01 == Zero and parity12 == One) {
            X(register[2]);
        }

        return parity01 == One or parity12 == One;
    }

    operation Encode(register : Qubit[]) : Unit is Adj
    {
        CNOT(register[0], register[1]);
        CNOT(register[0], register[2]);
    }

    operation MeasureBitFlipSyndrome(encodedRegister : Qubit[], auxiliaryRegister : Qubit[]) : (Result, Result)
    {
        // Measure the bit flip syndrome by checking the parities between qubits 0 and 1, and between qubits 1 and 2.
        ResetAll(auxiliaryRegister);
        CNOT(encodedRegister[0], auxiliaryRegister[0]);
        CNOT(encodedRegister[1], auxiliaryRegister[0]);
        CNOT(encodedRegister[1], auxiliaryRegister[1]);
        CNOT(encodedRegister[2], auxiliaryRegister[1]);
        let parity01 = MResetZ(auxiliaryRegister[0]);
        let parity12 = MResetZ(auxiliaryRegister[1]);
        return (parity01, parity12);
    }
}

Stellen Sie über ein Terminalfenster in VS Code eine Verbindung mit Ihrem Azure Quantum-Arbeitsbereich her, und legen Sie die Standardressourcen fest.
```
az login
```
Hinweis

Ihre Azure-Abonnement-ID, Ihre Ressourcengruppe und Ihr Arbeitsbereichsname können im Terminalfenster aufgeführt werden, nachdem Sie sich angemeldet haben, indem Sie az quantum workspace list ausführen. Alternativ finden Sie sie im Azure-Portal auf der Seite Übersicht Ihres Azure Quantum-Arbeitsbereichs.
```
az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
```

Übermitteln Sie den Auftrag, und zeigen Sie die Ergebnisse an. Bei dieser Ausführung werden ca. 11,31 eHQCs (Quantinuum-Emulator-Abrechnungseinheiten) verwendet.

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --job-name ErrorCorrection \
    --target-capability AdaptiveExecution \
    --shots 50

az quantum job output \
    -o table \
    --job-id [job-id]

Dieser Beispielcode wurde von Mitgliedern des KPMG Quantum-Teams in Australien geschrieben und fällt unter eine MIT-Lizenz. Ziel ist es, erweiterte Funktionen von Basic Measurement Feedbacktargets begrenzten Schleifen, klassische Funktionsaufrufe zur Laufzeit, geschachtelte bedingte If-Anweisungen, Mittelkreismessungen und Qubit-Wiederverwendung zu demonstrieren.

Zweidimensionale innere Produktberechnung mit iterativer Phasenschätzung auf drei Qubits

Dieses Beispielprogramm veranschaulicht eine iterative Phasenschätzung in Q#. Es verwendet die iterative Phasenschätzung, um ein inneres Produkt zwischen zwei 2-dimensionalen Vektoren zu berechnen, die auf einem target Qubit und einem Ancilla-Qubit codiert sind. Außerdem wird ein zusätzliches Steuerelementqubit initialisiert, das als einziges Qubit für die Messung verwendet wird.

Die Schaltung beginnt mit der Codierung des Vektorpaars für das target Qubit und das Ancilla-Qubit. Anschließend wendet er einen Oracle-Operator auf das gesamte Register an, gesteuert über das Steuerelementqubit, das im Zustand $\ket +$ eingerichtet ist. Der kontrollierte Oracle-Operator generiert eine Phase im Zustand $\ket 1$ des Kontrollqubits. Dies kann dann gelesen werden, indem ein H-Gate auf das Steuerqubit angewendet wird, um die Phase beim Messen beobachtbar zu machen.

Erstellen eines VS Code-Projekts

Erstellen Sie in VS Code ein neues Q# eigenständiges Konsolenanwendungsprojekt namens IPE.
1. Wählen Sie Befehlspalette >Q#anzeigen>: Erstellen einer neuen eigenständigen Projektkonsolenanwendung >

Ersetzen Sie die Konfiguration in IPE.csproj durch Folgendes:

<Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
  </PropertyGroup>

</Project>

Ersetzen Sie den Code in Program.qs durch Folgendes:

namespace IPE {

    //IMPORT LIBRARIES
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Convert;


    // additional code added here


}

Codierungsvektoren

Die Vektoren v und c sind auf das target Qubit und das Ancilla-Qubit zu codieren. Der Vektor $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ kann durch den Quantenzustand $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$ dargestellt werden, ähnlich $c$ mit $\theta_2$.

Eine Y-Drehung, die auf ein target Qubit im Zustand $\ket 0$ angewendet wird:

$$RY(\theta)\ket 0 = e^{iY\theta/2}\ket 0 = cos(\frac{\theta}{2})\ket 0 + sin(\frac{\theta}{2})\ket 1$$

Hinweis

Ein Faktor von 2 ist hier auf theta vorhanden. Eine Anwendung eines $RY(2\pi)$ Gate auf $\ket 0$ ergibt den Zustand $-\ket 0$ und würde den Vektor $(-1,0)$ codieren. Diese Phase kann nicht als globale Phase betrachtet werden und wird entfernt, da das gesamte Register verschränkt wird.

Das Register des target Qubit- und Ancilla-Qubits ist

$$\ket \Psi = \ket {\Psi_\text{Zielqubit}}\ket {\Psi_\text{Ancilla qubit}}$$

Der zu erstellende Zustand befindet sich auf dem target Qubit, und das Ancilla-Qubit ist

$$\ket{\Psi}=\frac{1}{\sqrt{2}}(\ket{v}\ket{+}+\ket{c}\ket{-}),$

die auch die Form hat

$$\ket{\Psi} = \frac{1}{2}(\ket{v}+\ket{c})\ket{0}+\frac{1}{2}(\ket{v}-\ket{c})\ket{1}.$$

Fügen Sie der Datei Program.qs den folgenden Vorgang hinzu.

//This is state preparation operator A for encoding the 2D vector
operation StateInitialisation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    H(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector v.
    Controlled R([AncilReg], (PauliY, theta_1, TargetReg));

    // X gate on ancilla to change from |+> to |->
    X(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector c.
    Controlled R([AncilReg], (PauliY, theta_2, TargetReg));
    X(AncilReg);
    H(AncilReg);
}

Das Orakel

Ein Orakel G muss so konstruiert werden, dass es eine Eigenphase für den Zustand generiert, der für das target Qubit und das Ancilla-Qubit codiert ist. Die Konstruktion dieses Orakels ist für die Demonstration in diesem Beispiel unwichtig, aber der angewendete Vorgang ist

$$G\ket \Psi = e^{2\pi i\phi} \ket \Psi.$$

wobei das innere Produkt $\braket {v|c}$ in der Phase $\phi$enthalten ist, die zwischen [0,1] gebunden ist. Bei Anwendung gesteuert auf das Steuerelement qubit, das in diesem Zustand beginnt $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Qubit}} \ket \Psi & = \frac {1}{\sqrt{2}} (\ket 0 \ket \Psi + e^{2\pi i\phi}\ket 1 \ket \Psi )\ & =\frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1) \ket \Psi \end{aligned}$$

Nun enthält das Steuerqubit die Phase, die sich auf das innere Produkt $\braket {v|c}$ bezieht.

$$\ket{\Psi_\text{Control Qubit}} = \frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1)$$

Fügen Sie der Datei Program.qs den folgenden Vorgang hinzu.

operation GOracle(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    Z(AncilReg);
        within {
            Adjoint StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);

            // Apply X gates individually here as currently ApplyAll is not Adj + Ctl
            X(AncilReg);
            X(TargetReg);
        }
        apply {
            Controlled Z([AncilReg],TargetReg);
        }
    }

Iteration

Nun zum iterativen Teil der Schaltung. Berücksichtigen Sie für n-Messungen, dass die Phase als binärwert $\phi$dargestellt werden kann, und dass das Anwenden von $2^n$-Orakeln den n. binären Punkt der Phase beobachtbar macht (durch einfache binäre Multiplikation und Modulus $2\pi$). Der Wert des Steuerelement-Qubits kann ausgelesen, in einem klassischen Register platziert werden und die Qubitzurücksetzung zur Verwendung in der nächsten Iteration. Die nächste Iteration wendet $2^{n-1}$ Orakel an, wobei die Phase auf dem Kontrollqubit abhängig von der n-ten Messung korrigiert wird. Der Zustand auf dem Steuerelement-Qubit kann als dargestellt werden.

$$ \ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i\phi}\ket 1 $$

wobei $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

Das Anwenden von $2^n$ kontrollierten Orakeln gibt den Zustand auf dem Steuerqubit an.

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n\phi_{n+1}\phi_{n+2}\phi_{n+3}...} \ket 1 $$

Beachten Sie, dass die Phase keine tieferen Begriffe enthält als $\phi_n$ (d. h. Begriffe $\phi_{n+1},\phi_{n+2}, \text{etc}$).

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n}\ket 1 $$

Nun kann der Wert $\phi_n$ mit einem H-Gate und einer Messung beobachtet werden, die entlang der Z-Achse projiziert wird. Zurücksetzen des Steuerelementqubits und Anwenden des Orakels $2^{n-1}$ mal

$$ G^{2^{n-1}}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}\phi_n}\ket 1 $$

Mithilfe des vorherigen Messwerts für $\phi_n$kann der zusätzliche binäre Punkt herausgedreht werden.

$$ RZ(-2\pi \times 0.0\phi_n)G^{n-1}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}}\ket 1 $$

Dieser Prozess wird für eine gewisse Bitgenauigkeit n iterativ angewendet, um die Phase $0.\phi_0\phi_1\phi_2...\phi_{n}$ abzurufen. Der Wert wird als Binärwert $x = \phi_0\phi_1\phi_2...\phi_{n}$gespeichert, da derzeit nur ganze Zahlen zur Laufzeit manipuliert werden können.

Da das Auslesen nichts von beiden Vektoren sagt, bleiben nur das innere Produkt zwischen ihnen, die Zustände auf dem target Qubit und dem Ancilla-Qubit während des gesamten Prozesses im gleichen Zustand !

Fügen Sie der Datei Program.qs den folgenden Vorgang hinzu.

operation IterativePhaseEstimation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double, Measurements : Int) : Int{
    use ControlReg = Qubit();
    mutable MeasureControlReg = [Zero, size = Measurements];
    mutable bitValue = 0;

    //Apply to initialise state, this is defined by the angles theta_1 and theta_2
    StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);
    for index in 0 .. Measurements - 1{
        H(ControlReg);

        //Don't apply rotation on first set of oracles
        if index > 0 {

            //Loop through previous results
            for index2 in 0 .. index - 1{
                if MeasureControlReg[Measurements - 1 - index2] == One{
                    let angle = -IntAsDouble(2^(index2))*PI()/(2.0^IntAsDouble(index));

                    //Rotate control qubit dependent on previous measurements and number of measurements
                    R(PauliZ, angle, ControlReg);
                }
            }
        }
        let powerIndex = (1 <<< (Measurements - 1 - index));

        //Apply a number of oracles equal to 2^index, where index is the number or measurements left
        for _ in 1 .. powerIndex{
                Controlled GOracle([ControlReg],(TargetReg, AncilReg, theta_1, theta_2));
            }
        H(ControlReg);

        //Make a measurement mid circuit
        set MeasureControlReg w/= (Measurements - 1 - index) <- MResetZ(ControlReg);
        if MeasureControlReg[Measurements - 1 - index] == One{

            //Assign bitValue based on previous measurement
            set bitValue += 2^(index);

        }
    }
    return bitValue;
}

Berechnen des inneren Produkts

Berechnen Sie schließlich das innere Produkt aus dem Messwert.

$$\braket {v|c} = -cos(2\pi x / 2^n)$$

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. Der Nenner innerhalb der Kosinusfunktion besteht darin, den binären Punkt so zu verschieben, dass er dem ursprünglichen Wert $\phi$ entspricht.

Hinweis

Bei inneren Produkten, die nicht -1 oder 1 sind, werden die Lösungen mit einer Wertdifferenz von $2^{n-1}$ gekoppelt. Für n=3-Messungen würde der gemessene Bitwert von 2 auch eine Paarlösung von 6 aufweisen. Jeder dieser Werte erzeugt den gleichen Wert des inneren Produkts, wenn er als Variable für den geraden Funktionskosinus eingegeben wird (was in diesem Beispiel zu einem inneren Produkt von 0 führt).

Bei inneren Produktlösungen zwischen der diskreten Bitgenauigkeit wird eine Verteilung der Ergebnisse basierend darauf erzeugt, wo sich das innere Produkt zwischen dem diskreten Bitwert befindet.

Fügen Sie der Datei Program.qs den folgenden Vorgang hinzu.

function CalculateInnerProduct(Results : Int, theta_1 : Double, theta_2 : Double, Measurements : Int): Unit{
    let DoubleVal = PI() * IntAsDouble(Results) / IntAsDouble(2 ^ (Measurements-1));

    //Convert to the final inner product
    let InnerProductValue = -Cos(DoubleVal);
    Message("The Bit Value measured is:");
    Message($"{Results}");
    Message("The Inner Product is:");
    Message($"{InnerProductValue}");
    Message("The True Inner Product is:");
    Message($"{Cos(theta_1/2.0)*Cos(theta_2/2.0)+Sin(theta_1/2.0)*Sin(theta_2/2.0)}");
}

Ausführen des Programms

Jetzt können Sie das Programm testen. Zunächst führen Sie das Programm mithilfe eines Simulationsvorgangs lokal aus, und dann stellen Sie eine Verbindung mit Azure Quantum her und führen es auf einer Hardware targetaus.

Simulieren der iterativen Phasenschätzung

Q# Programme benötigen einen @EntryPoint() , um dem Compiler mitzuteilen, wo die Ausführung des Programms gestartet werden soll. Fügen Sie Programs.qs den folgenden Code hinzu, um das Programm mit dem SimulateInnerProduct() Vorgang zu starten. Diese Version des inneren Produktvorgangs gibt zusätzliche Informationen aus, einschließlich der Bearbeitung von Doubles, von denen die Ausgabe im Terminal angezeigt wird.

@EntryPoint()

//Operation for calculating the inner product on local simulators
operation SimulateInnerProduct() : Unit{

    //This operation will output additional classical calculations
    let (Results, theta_1, theta_2, Measurements) = InnerProduct();
    CalculateInnerProduct(Results, theta_1, theta_2, Measurements);
}

operation InnerProduct() : (Int, Double, Double, Int){

    //Specify the angles for inner product
    let theta_1 = 0.0;
    let theta_2 = 0.0;
    let Measurements = 3;

    //Create target register
    use TargetReg = Qubit();

    //Create ancilla register
    use AncilReg = Qubit();

    //This runs iterative phase estimation
    let Results = IterativePhaseEstimation(TargetReg, AncilReg, theta_1, theta_2, Measurements);
    Reset(TargetReg);
    Reset(AncilReg);
    return (Results, theta_1, theta_2, Measurements);
}

Um das Programm auszuführen, öffnen Sie ein Terminalfenster in VS Code, und führen Sie aus

    dotnet run

Ausführen in einer Azure Quantum-Instanz target

Um für eine Hardware targetauszuführen, ersetzen Sie den SimulateInnerProduct() Vorgang durch den folgenden HardwareInnerProduct() Vorgang:

//Operation for calculating the inner product on hardware or emulators
operation HardwareInnerProduct() : Int{
    let (Results,_,_,_) = InnerProduct();
    return Results;
}

Stellen Sie als Nächstes eine Verbindung mit Ihrem Azure Quantum-Arbeitsbereich her, und legen Sie die Standardressourcen fest.

az login

Hinweis

Ihre Azure-Abonnement-ID, Ihre Ressourcengruppe und Ihr Arbeitsbereichsname können im Terminalfenster aufgeführt werden, nachdem Sie sich angemeldet haben, indem Sie az quantum workspace list ausführen. Alternativ finden Sie sie im Azure-Portal auf der Seite Übersicht Ihres Azure Quantum-Arbeitsbereichs.

az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>

Übermitteln Sie den Auftrag mit den folgenden Parametern:

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --target-capability AdaptiveExecution \
    --shots 50 \
    --job-name IterativePhaseEstimation

Hinweis

Die angegebene target erfordert ein target Ausführungsprofil, das unterstützt Basic Measurement Feedback.

Wichtig

Es wird nicht empfohlen, den Wert von Measurements über 3 zu erhöhen, wenn sie in Azure targets ausgeführt werden, da die eHQCs erheblich steigen können.

Sie können die status des Auftrags mit anzeigen.

az quantum job output \
    -o table \
    --job-id [job-id]

Ersetzen Sie [job-id] durch die angezeigte Auftrags-ID. Die Ergebnisse zeigen eine Lösung im Zustand mit der Mehrheitsbevölkerung. Das innere Endprodukt aus den ganzzahligen Ergebnissen kann mit $\braket {v|c} = -cos(2\pi x / 2^n)$ berechnet werden, wobei n die anzahl der im Auftrag angegebenen Messungen ist.

Hinweis

Die Auswahl von Eingabeparametern, die nur über einen Lösungszustand (innere Produkte von -1 oder 1) verfügen, sind ideal für die Sichtbarkeit, wenn eine geringe Anzahl von Aufnahmen verwendet wird.

Nächste Schritte

Verteiltes Hybrid Computing

Integriertes Hybridcomputing

Unterstützung von targets

Quantinuum

Erste Schritte

Übermitteln integrierter Hybridaufträge

IchQ#

Python + Q#

Azure CLI

Übermitteln integrierter Hybridaufträge innerhalb einer Sitzung

Schätzen der Kosten eines integrierten Hybridauftrags

Integrierte Hybridbeispiele

Voraussetzungen

Erstellen eines VS Code-Projekts

Nächste Schritte

Feedback

Feedback

Zusätzliche Ressourcen