Geïntegreerde hybride computing

Geïntegreerde hybride computing brengt de klassieke en kwantumprocessen samen, waardoor klassieke code de uitvoering van kwantumbewerkingen kan beheren op basis van metingen in het middencircuit, terwijl de fysieke qubits in leven blijven. Met behulp van veelgebruikte programmeertechnieken, zoals geneste voorwaardelijkheden, lussen en functie-aanroepen, kan één kwantumprogramma complexe problemen uitvoeren, waardoor het aantal opnamen dat nodig is, wordt verminderd. Met behulp van technieken voor hergebruik van qubits kunnen grotere programma's worden uitgevoerd op computers die gebruikmaken van een kleiner aantal qubits.

Belangrijk

Geïntegreerde hybride kwantumcomputing wordt momenteel niet ondersteund door de extensie Modern Quantum Development Kit (Modern QDK) voor Visual Studio Code, samen met andere onderdelen in de voorbeelden op deze pagina, zoals de I-kernelQ# , de %azure magic-opdracht of de qsharp.azure module. Als u geïntegreerde hybride taken wilt uitvoeren, gebruikt u microsoft Quantum Development Kit (klassieke QDK). Zie Doorgaan met werken in de klassieke QDK voor meer informatie.

Zie voor meer informatie:

• Granade & Weibe, "Using Random Walks for Iterative Phase Estimation".
• Lubinski, et al., "Advancing Hybrid Quantum–Classical Computation with Real-Time Execution"

Ondersteund targets

Momenteel wordt het geïntegreerde hybride computingmodel in Azure Quantum ondersteund op Quantinuumtargets.

Quantinuum

Ondersteunde functie	Notities
Klassieke lussen	Alleen gebonden lussen
Willekeurige controlestroom	Gebruik van if/else-vertakking
Meting van mid-circuit	Maakt gebruik van klassieke registerresources
Qubit opnieuw gebruiken	N.v.t.
Klassieke berekeningen in realtime	Rekenkundig 32-bits geheel getal zonder teken Maakt gebruik van klassieke registerresources

Aan de slag

Als u geïntegreerde hybride programmering wilt verkennen, raden we u aan de voorbeelden in dit artikel door te nemen of het tabblad Hybride kwantumcomputing te verkennen in de galerie Voorbeelden van de Azure Quantum-portal.

Geïntegreerde hybride taken indienen

Wanneer u een geïntegreerde hybride taak indient, moet u een target mogelijkheidsparameter toevoegen nadat u de targethebt opgegeven. Daarnaast worden geïntegreerde hybride programma's in Azure Quantum uitgevoerd en beheerd, net als gewone kwantumtaken. Elke taak heeft één taak-id en het resultaat is één histogram.

Belangrijk

Geïntegreerde hybride kwantumcomputing wordt momenteel niet ondersteund door de extensie Modern Quantum Development Kit (Modern QDK) voor Visual Studio Code, samen met andere onderdelen in de voorbeelden op deze pagina, zoals de I-kernelQ# , de %azure magic-opdracht of de qsharp.azure module. Als u geïntegreerde hybride taken wilt uitvoeren, gebruikt u microsoft Quantum Development Kit (klassieke QDK). Zie Doorgaan met werken in de klassieke QDK voor meer informatie.

IQ#

Wanneer u de I-kernelQ# in een Jupyter Notebook gebruikt, gebruikt u %azure.target-capability magic-opdracht met de AdaptiveExecution parameter .

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

Python + Q#

Wanneer u het Python-pakket qsharp gebruikt, gebruikt u de qsharp.azure.target_capability functie met de AdaptiveExecution parameter .

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

Azure CLI

Wanneer u de Azure CLI gebruikt om een taak te verzenden, voegt u de --target-capability parameter toe met de waarde AdaptiveExecution.

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

Geïntegreerde hybride taken verzenden binnen een sessie

U kunt meerdere geïntegreerde hybride taken binnen een sessie combineren met behulp van Q# en Python. Wanneer u een sessie verzendt, voegt u de targetCapability invoerparameter toe met de waarde AdaptiveExecution.

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

Zie Aan de slag met sessies voor meer informatie.

Notitie

Hoewel sessies beschikbaar zijn voor alle hardwareproviders voor kwantumcomputing, ziet u dat geïntegreerde hybride kwantumcomputingtaken momenteel worden ondersteund op Quantinuum targets.

De kosten van een geïntegreerde hybride taak schatten

U kunt de kosten van het uitvoeren van een geïntegreerde hybride taak op Quantinuum-hardware schatten door deze eerst op een emulator uit te voeren.

Na een geslaagde uitvoering op de emulator:

1. Selecteer Taakbeheer in uw Azure Quantum-werkruimte.
2. Selecteer de taak die u hebt verzonden.
3. Selecteer in het pop-upvenster Taakdetailsde optie Kostenraming om weer te geven hoeveel eHQC's (Quantinuum-emulatortegoeden) zijn gebruikt. Dit getal wordt rechtstreeks omgezet in het aantal HQCs (Quantinuum quantum credits) dat nodig is om de taak uit te voeren op Quantinuum-hardware.

Notitie

Met Quantinuum wordt het hele circuit uitgeschreven en worden de kosten voor alle codepaden berekend, ongeacht of ze voorwaardelijk worden uitgevoerd of niet.

Geïntegreerde hybride voorbeelden

In de volgende voorbeelden ziet u de huidige functieset voor geïntegreerde hybride computing.

• Een verstrengelde GHZ-status controleren
• Herhaling van drie qubits
• Iteratieve faseschatting

Vereisten

• Als u geen gebruik hebt van Azure Quantum, hebt u een Azure-abonnement en een Azure Quantum-werkruimte nodig om de voorbeelden uit te voeren op kwantumhardware. Zie Een Azure Quantum-werkruimte maken voor meer informatie.
• VS Code en de Quantum Development Kit installatie in uw lokale omgeving. Zie De instellen Quantum Development Kitvoor meer informatie.
• Zorg ervoor dat VS Code de nieuwste versie van de Quantum Development Kit (0.27.258160) heeft.
  • Selecteer in VS Code Ctrl + Shift + X en zoek naar 'Microsoft Quantum Development Kit'.

De voorbeelden in dit artikel zijn ingesteld om te worden uitgevoerd in Visual Studio (VS) Code en gebruiken de ingebouwde Azure-opdrachtregelinterface (CLI) om de taak naar Azure Quantum te verzenden. Als u de Jupyter Notebook versie van deze en andere voorbeelden wilt uitvoeren, meldt u zich aan bij uw Azure Portal werkruimte en bekijkt u de voorbeelden op het tabblad Hybride kwantumcomputing in de galerie Voorbeelden. U kunt het notebook uitvoeren in de cloud of het downloaden en lokaal uitvoeren.

Zie Problemen met geïntegreerde hybride oplossen om problemen met geïntegreerde hybride programma's op te lossen.

GHZ-status controleren

In dit voorbeeld ontdekt u hoe u klassieke en kwantuminstructies combineert in hetzelfde programma, allemaal volledig verwerkt door de back-end van kwantumcomputing.

Functies om rekening mee te houden over dit voorbeeld:

• De lus- en qubitmetingen vinden plaats terwijl de qubits coherent blijven.
• De routine combineert klassieke en kwantumberekeningsbewerkingen.
• U hoeft niet te leren programmeren voor gespecialiseerde hardware met hoge prestaties die naast de QPU wordt uitgevoerd (zoals FPGA's).
• Als u een equivalent programma uitvoert zonder de geïntegreerde hybride functies, moet elk tussenliggend meetresultaat worden geretourneerd en vervolgens de naverwerking van de gegevens worden uitgevoerd.

Een VS Code-project maken

1. Maak in VS Code een nieuw Q# zelfstandig consoletoepassingsproject met de naam CheckGHZ.

   1. Selecteer Opdrachtpallet weergeven >>Q#: Nieuwe project > zelfstandige consoletoepassing maken

2. Vervang de configuratie in CheckGHZ.csproj door het volgende:

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

3. Vervang de code in Program.qs door het volgende:

   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;
       }
   }
   

4. Maak vanuit een terminalvenster in VS Code verbinding met uw Azure Quantum-werkruimte en stel de standaardresources in.

   az login
   

   Notitie

   Uw Azure-abonnements-id, resourcegroep en werkruimtenaam kunnen worden weergegeven in het terminalvenster nadat u zich hebt aangemeld door az quantum workspace list uit te voeren. U kunt ze ook vinden in de Azure Portal op de pagina Overzicht van uw Azure Quantum-werkruimte.

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

5. Verzend de taak en bekijk de resultaten. Voor deze uitvoering worden ongeveer 10,65 eHQC's (quantinuum-emulatorfactureringseenheden) gebruikt

   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]
   

Herhalingscode met drie qubits

In dit voorbeeld ziet u hoe u een 3-qubit-herhalingscode maakt die kan worden gebruikt om bit-flipfouten te detecteren en te corrigeren.

Het maakt gebruik van geïntegreerde functies voor hybride computing om te tellen hoe vaak foutcorrectie is uitgevoerd terwijl de status van een logisch qubitregister coherent is.

Een VS Code-project maken

1. Maak in VS Code een nieuw Q# zelfstandig consoletoepassingsproject met de naam ThreeQubit.

   1. Selecteer Opdrachtpallet > weergeven >Q#: Nieuwe project > zelfstandige consoletoepassing maken

2. Vervang de configuratie in ThreeQubit.csproj door het volgende:

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

3. Vervang de code in Program.qs door het volgende:

   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);
       }
   }
   

4. Maak vanuit een terminalvenster in VS Code verbinding met uw Azure Quantum-werkruimte en stel de standaardresources in.

   az login
   

   Notitie

   Uw Azure-abonnements-id, resourcegroep en werkruimtenaam kunnen worden weergegeven in het terminalvenster nadat u zich hebt aangemeld door az quantum workspace list uit te voeren. U kunt ze ook vinden in de Azure Portal op de pagina Overzicht van uw Azure Quantum-werkruimte.

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

5. Verzend de taak en bekijk de resultaten. Deze uitvoering maakt gebruik van ongeveer 11,31 eHQC's (Quantinuum emulator-factureringseenheden)

   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]
   

Iteratieve faseschatting

Deze voorbeeldcode is geschreven door leden van het KPMG Quantum-team in Australië en valt onder een MIT-licentie. Het is gericht op het demonstreren van uitgebreide mogelijkheden van Basic Measurement Feedbacktargets en maakt gebruik van begrensde lussen, klassieke functieaanroepen tijdens runtime, geneste voorwaardelijke if-instructies, mid circuitmetingen en qubit-hergebruik.

Tweedimensionale binnenste productberekening met behulp van iteratieve faseschatting op drie qubits

Dit voorbeeldprogramma demonstreert een iteratieve faseschatting binnen Q#. Er wordt gebruikgemaakt van iteratieve faseschatting om een binnenste product te berekenen tussen twee 2-dimensionale vectoren die zijn gecodeerd op een target qubit en een ancilla-qubit. Er wordt ook een extra controle-qubit geïnitialiseerd. Dit is de enige qubit die wordt gebruikt voor meting.

Het circuit begint met het coderen van het paar vectoren op de target qubit en de ancilla-qubit. Vervolgens wordt een Oracle-operator toegepast op het hele register, waarbij de controle-qubit wordt gecontroleerd, die is ingesteld in de status $\ket +$. De beheerde Oracle-operator genereert een fase op de $\ket 1$ status van de controle-qubit. Dit kan vervolgens worden gelezen door een H-poort toe te passen op de controle-qubit om de fase waarneembaar te maken bij het meten.

Een VS Code-project maken

1. Maak in VS Code een nieuw Q# zelfstandig consoletoepassingsproject met de naam IPE.

   1. Selecteer Opdrachtpallet > weergeven >Q#: Nieuwe project > zelfstandige consoletoepassing maken

2. Vervang de configuratie in IPE.csproj door het volgende:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
     </PropertyGroup>
   
   </Project>
   

3. Vervang de code in Program.qs door het volgende:

   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
   
   
   }
   

Encoding vectoren

De vectoren v en c moeten worden gecodeerd op de target qubit en de ancilla-qubit. De vector $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ kan worden vertegenwoordigd door de kwantumtoestand $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, op dezelfde manier kan $c$ worden samengesteld met $\theta_2$.

Een Y-rotatie die wordt toegepast op een target qubit met de status $\ket 0$:

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

Notitie

Een factor 2 is hier aanwezig op theta. Een toepassing van een poort $RY(2\pi)$ op $\ket$ geeft de status $-\ket 0$ en codeert de vector $(-1,0)$. Deze fase kan niet worden beschouwd als een globale fase en wordt verwijderd omdat het hele register wordt verstrengeld.

Het register van de target qubit en ancilla-qubit is

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

De status die moet worden gemaakt, is op de target qubit en de ancilla-qubit is

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

die ook de vorm krijgt

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

Voeg de volgende bewerking toe aan het bestand Program.qs .

//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);
}

Het Orakel

Een orakel G moet zodanig worden geconstrueerd dat er een eigenfase wordt gegenereerd op de status die is gecodeerd op de target qubit en de ancilla-qubit. De constructie van dit orakel is niet van belang voor de demonstratie in dit voorbeeld, maar de bewerking die wordt toegepast, is

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

waarbij het binnenste product $\braket {v|c}$ zich bevindt in de fase $\phi$, die is gebonden tussen [0,1]. Indien toegepast op de controle-qubit die begint in die toestand $\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}$$

De controle-qubit bevat nu de fase die betrekking heeft op het binnenste product $\braket {v|c}$

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

Voeg de volgende bewerking toe aan het bestand Program.qs .

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);
        }
    }

Iteratie

Nu het iteratieve deel van het circuit. Houd er bij n metingen rekening mee dat de fase kan worden weergegeven als een binaire waarde $\phi$, en dat het toepassen van $2^n$ oracles het nde binaire punt van de fase waarneembaar maakt (door eenvoudige binaire vermenigvuldiging en modulus $2\pi$). De waarde van de controle-qubit kan worden uitgelezen, in een klassiek register worden geplaatst en de qubit opnieuw worden ingesteld voor gebruik in de volgende iteratie. De volgende iteratie past $2^{n-1}$ oracles toe, waarbij de fase op de controle-qubit wordt gecorrigeerd, afhankelijk van de nde meting. De status op de controle-qubit kan worden weergegeven als

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

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

Het toepassen van $2^n$ gecontroleerde orakels geeft de status op de controle-qubit

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

Houd er rekening mee dat de fase geen termen bevat die dieper zijn dan $\phi_n$ (dat wil gezegd, termen $\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 $$

Nu kan de waarde $\phi_n$ worden waargenomen met een H-poort en een meting die langs de Z-as projecteert. De controle-qubit opnieuw instellen en het oracle $2^{n-1}$ keer toepassen

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

Met behulp van de vorige gemeten waarde voor $\phi_n$ kan het extra binaire punt worden gedraaid

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

Dit proces wordt iteratief toegepast voor een bitprecisie n om de fase $0.\phi_0\phi_1\phi_2...\phi_{n}$ te verkrijgen. De waarde wordt opgeslagen als een binaire waarde $x = \phi_0\phi_1\phi_2...\phi_{n}$, omdat op dit moment alleen gehele getallen kunnen worden bewerkt tijdens runtime.

Aangezien de uitlezing niets vertelt over een van beide vectoren, blijven alleen het binnenste product ertussen, de toestanden op de target qubit en ancilla-qubit in dezelfde toestand gedurende het hele proces!

Voeg de volgende bewerking toe aan het bestand Program.qs .

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;
}

Het binnenste product berekenen

Bereken ten slotte het binnenste product van de gemeten waarde

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

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. De noemer binnen de cosinusfunctie is om het binaire punt te verplaatsen zodat deze overeenkomt met de oorspronkelijke waarde $\phi$.

Notitie

Voor het binnenste product dat niet -1 of 1 is, worden de oplossingen gekoppeld aan een waardeverschil van $2^{n-1}$. Voor n=3 metingen heeft de gemeten bitwaarde 2 bijvoorbeeld ook een paaroplossing van 6. Een van deze waarden produceert dezelfde waarde van het binnenste product bij invoer als de variabele voor de cosinus van de even functie (wat in dit voorbeeld resulteert in een binnenste product van 0).

Voor interne productoplossingen tussen de discrete bitprecisie wordt een verdeling van de resultaten geproduceerd op basis van waar het binnenste product zich bevindt tussen de discrete bitwaarde.

Voeg de volgende bewerking toe aan het bestand Program.qs .

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

Het programma uitvoeren

Nu kunt u het programma testen. Eerst voert u het programma lokaal uit met behulp van een simulatiebewerking en vervolgens maakt u verbinding met Azure Quantum en voert u het uit op een hardware target.

Iteratieve faseschatting simuleren

Q# programma's vereisen een @EntryPoint() om de compiler te laten weten waar de uitvoering van het programma moet worden gestart. Voeg de volgende code toe aan Programs.qs om het programma met de SimulateInnerProduct() bewerking te starten. Deze versie van de bewerking van het interne product voert aanvullende informatie uit, waaronder de manipulatie van dubbele waarden waarvan de uitvoer wordt weergegeven in de terminal.

@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);
}

Als u het programma wilt uitvoeren, opent u een terminalvenster in VS Code en voert u

    dotnet run

Uitvoeren op een Azure Quantum target

Als u wilt uitvoeren op een hardware target, vervangt u de SimulateInnerProduct() bewerking door de volgende HardwareInnerProduct() bewerking:

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

Maak vervolgens verbinding met uw Azure Quantum-werkruimte en stel de standaardresources in.

az login

Notitie

Uw Azure-abonnements-id, resourcegroep en werkruimtenaam kunnen worden weergegeven in het terminalvenster nadat u zich hebt aangemeld door az quantum workspace list uit te voeren. U kunt ze ook vinden in de Azure Portal op de pagina Overzicht van uw Azure Quantum-werkruimte.

az account set --subscription <MySubscriptionID>

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

Verzend de taak met de volgende parameters:

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

Notitie

De opgegeven target vereist een target uitvoeringsprofiel dat ondersteuning biedt voor Basic Measurement Feedback.

Belangrijk

Het wordt niet aanbevolen om de waarde van Measurements meer dan 3 te verhogen bij het uitvoeren in Azure targets , omdat de eHQC's aanzienlijk kunnen toenemen.

U kunt de status van de taak weergeven met

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

[job-id] vervangen door de weergegeven taak-id. De resultaten tonen een oplossing in de staat met de meerderheid van de bevolking. Het uiteindelijke binnenste product van de resultaten van het gehele getal kan worden berekend door $\braket {v|c} = -cos(2\pi x / 2^n)$, waarbij n het aantal metingen is dat in de taak is opgegeven.

Notitie

Het selecteren van invoerparameters die slechts één oplossingsstatus hebben (binnenproducten van -1 of 1) zijn ideaal voor zichtbaarheid bij het gebruik van een laag aantal opnamen.

Volgende stappen

Gedistribueerde hybride computing