Elaborazione ibrida integrata

Il calcolo ibrido integrato riunisce i processi classici e quantistici, consentendo al codice classico di controllare l'esecuzione di operazioni quantistiche basate sulle misurazioni a circuito intermedio mentre i qubit fisici rimangono attivi. Usando tecniche di programmazione comuni, ad esempio condizionali annidati, cicli e chiamate di funzione, un singolo programma quantistico può eseguire problemi complessi, riducendo il numero di colpi necessari. Usando le tecniche di riutilizzo di qubit, i programmi più grandi possono essere eseguiti nei computer che usano un numero minore di qubit.

Importante

Il calcolo quantistico ibrido integrato non è attualmente supportato dall'estensione Modern (Modern Quantum Development Kit QDK) per Visual Studio Code, insieme ad altri componenti presenti in questa pagina, ad esempio il kernel IQ# , il comando magic o il %azureqsharp.azure modulo. Per eseguire processi ibridi integrati, usare Microsoft Quantum Development Kit (QDK classico). Per altre informazioni, vedere Continuare a lavorare in QDK classico.

Per altre discussioni, vedere:

• Granade & Weibe, "Uso di passeggiate casuali per la stima della fase iterativa".
• Lubinski, et al., "Avanzamento del calcolo quantistico ibrido classico con Real-Time esecuzione"

Aggiunta del supporto per targets

Attualmente, il modello di calcolo ibrido integrato in Azure Quantum è supportato in Quantinuumtargets.

Quantinuum

Funzionalità supportata	Note
Cicli classici	Cicli delimitati solo
Flusso di controllo arbitrario	Uso di if/else branching
Misurazione del circuito intermedio	Usa le risorse di registrazione classiche
Riutilizzo di Qubit	N/D
Calcolo classico in tempo reale	Aritmetica intero senza segno a 32 bit Usa le risorse di registrazione classiche

Introduzione

Per iniziare a esplorare la programmazione ibrida integrata, è consigliabile esplorare gli esempi in questo articolo o esplorare la scheda Calcolo quantistico ibrido nella raccolta Esempi del portale di Azure Quantum.

Invio di processi ibridi integrati

Quando si invia un processo ibrido integrato, è necessario aggiungere un target parametro di funzionalità dopo aver specificato .target Oltre a questo, i programmi ibridi integrati in Azure Quantum vengono eseguiti e gestiti esattamente come i processi quantistici regolari. Ogni processo ha un singolo ID processo e il risultato è un singolo istogramma.

Importante

Il calcolo quantistico ibrido integrato non è attualmente supportato dall'estensione Modern (Modern Quantum Development Kit QDK) per Visual Studio Code, insieme ad altri componenti presenti in questa pagina, ad esempio il kernel IQ# , il comando magic o il %azureqsharp.azure modulo. Per eseguire processi ibridi integrati, usare Microsoft Quantum Development Kit (QDK classico). Per altre informazioni, vedere Continuare a lavorare in QDK classico.

HoQ#

Quando si usa il kernel IQ# in un Jupyter Notebook, usare %azure.target-capability magic command with the AdaptiveExecution parameter .

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

Python + Q#

Quando si usa il pacchetto Python qsharp , usare la funzione con il qsharp.azure.target_capabilityAdaptiveExecution parametro .

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

Interfaccia della riga di comando di Azure

Quando si usa l'interfaccia della riga di comando di Azure per inviare un processo, aggiungere il --target-capability parametro con il valore AdaptiveExecution.

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

Invio di processi ibridi integrati all'interno di una sessione

È possibile combinare più processi ibridi integrati all'interno di una sessione usando Q# e Python. Quando si invia una sessione, aggiungere il targetCapability parametro di input con il valore 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

Per altre informazioni, vedere Introduzione alle sessioni.

Nota

Anche se le sessioni sono disponibili per tutti i provider hardware di calcolo quantistico quantistico, si noti che i processi di calcolo quantistico ibridi integrati sono attualmente supportati in Quantinuum targets.

Stima del costo di un processo ibrido integrato

È possibile stimare il costo dell'esecuzione di un processo ibrido integrato nell'hardware Quantinuum eseguendolo prima in un emulatore.

Dopo un'esecuzione riuscita nell'emulatore:

1. Nell'area di lavoro Azure Quantum selezionare Gestione processi.
2. Selezionare il processo inviato.
3. Nel popup Dettagli processo selezionare Stima costi per visualizzare il numero di crediti dell'emulatore Quantinuum (Quantinuum emulatore). Questo numero si traduce direttamente nel numero di HQCs (crediti quantistici Quantinuum) necessari per eseguire il processo nell'hardware Quantinuum.

Nota

Quantinuum annulla la registrazione dell'intero circuito e calcola il costo su tutti i percorsi di codice, indipendentemente dal fatto che vengano eseguiti in modo condizionale o meno.

Esempi ibridi integrati

Gli esempi seguenti illustrano il set di funzionalità corrente per l'elaborazione ibrida integrata.

• Verificare uno stato GHZ intangled
• Ripetizione di tre qubit
• Stima di fase iterativa

Prerequisiti

• Se non si ha esperienza con Azure Quantum, è necessaria una sottoscrizione di Azure e un'area di lavoro di Azure Quantum per eseguire gli esempi sull'hardware quantistico. Per altre informazioni, vedere Creare un'area di lavoro di Azure Quantum.
• VS Code e la configurazione nell'ambiente Quantum Development Kit locale. Per altre informazioni, vedere Configurare .Quantum Development Kit
• Assicurarsi che VS Code abbia la versione più recente dell'oggetto Quantum Development Kit (0.27.258160).
  • In VS Code selezionare CTRL + MAIUSC + X e cercare "Microsoft Quantum Development Kit".

Gli esempi in questo articolo sono configurati per l'esecuzione in Visual Studio (VS) Code e usano l'interfaccia della riga di comando di Azure predefinita per inviare il processo ad Azure Quantum. Per eseguire la versione Jupyter Notebook di questi e altri esempi, accedere all'area di lavoro portale di Azure e visualizzare gli esempi dalla scheda Calcolo quantistico ibrido nella raccolta Esempi. È possibile eseguire il notebook nel cloud o scaricarlo ed eseguirlo in locale.

Per risolvere i problemi relativi ai programmi ibridi integrati, vedere Risoluzione dei problemi relativi all'ibrido integrato.

Controllare lo stato GHZ

In questo esempio si scoprirà come combinare istruzioni classiche e quantistiche nello stesso programma, tutto completamente elaborato dal back-end di calcolo quantistico.

Funzionalità da notare per questo esempio:

• Le misurazioni del ciclo e del qubit si verificano mentre i qubit rimangono coerenti.
• La routine combina operazioni di calcolo classiche e quantistiche.
• Non è necessario imparare a programmare l'hardware ad alte prestazioni specializzato in esecuzione accanto alla QPU (ad esempio FPGAs).
• L'esecuzione di un programma equivalente senza le funzionalità ibride integrate richiederebbe la restituzione di ogni risultato di misura intermedia e quindi l'esecuzione di post-elaborazione sui dati.

Creare un progetto VS Code

1. In VS Code creare un nuovo Q# progetto di applicazione console autonomo denominato CheckGHZ.

   1. Selezionare Visualizza > pallet dei >Q#comandi : Creare una nuova applicazione console autonoma del progetto >

2. Sostituire la configurazione in CheckGHZ.csproj con quanto segue:

   <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. Sostituire il codice in Program.qs con quanto segue:

   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. Da una finestra del terminale in VS Code connettersi all'area di lavoro Azure Quantum e impostare le risorse predefinite.

   az login
   

   Nota

   L'ID sottoscrizione di Azure, il gruppo di risorse e il nome dell'area di lavoro possono essere elencati nella finestra del terminale dopo l'accesso eseguendo az quantum workspace list. In alternativa, è possibile trovarli nella portale di Azure nella pagina Panoramica dell'area di lavoro Azure Quantum.

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

5. Inviare il processo e visualizzare i risultati. Questa esecuzione usa circa 10.65 eHQCs (unità di fatturazione dell'emulatore Quantinuum)

   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]
   

Codice di ripetizione a tre qubit

Questo esempio illustra come creare un codice di ripetizione a 3 qubit che può essere usato per rilevare e correggere gli errori di scorrimento dei bit.

Sfrutta le funzionalità di calcolo ibrido integrate per contare il numero di volte in cui è stata eseguita la correzione degli errori mentre lo stato di un registro qubit logico è coerente.

Creare un progetto VS Code

1. In VS Code creare un nuovo Q# progetto di applicazione console autonomo denominato ThreeQubit.

   1. Selezionare Visualizza > pallet dei >Q#comandi : Creare una nuova applicazione console autonoma del progetto >

2. Sostituire la configurazione in ThreeQubit.csproj con quanto segue:

   <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. Sostituire il codice in Program.qs con quanto segue:

   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. Da una finestra del terminale in VS Code connettersi all'area di lavoro Azure Quantum e impostare le risorse predefinite.

   az login
   

   Nota

   L'ID sottoscrizione di Azure, il gruppo di risorse e il nome dell'area di lavoro possono essere elencati nella finestra del terminale dopo l'accesso eseguendo az quantum workspace list. In alternativa, è possibile trovarli nella portale di Azure nella pagina Panoramica dell'area di lavoro Azure Quantum.

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

5. Inviare il processo e visualizzare i risultati. Questa esecuzione usa circa 11.31 eHQCs (unità di fatturazione dell'emulatore Quantinuum)

   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]
   

Stima di fase iterativa

Questo codice di esempio è stato scritto dai membri del team quantistico di KPMG in Australia e rientra in una licenza MIT. Mira a illustrare le funzionalità espanse di e fa uso di cicli delimitati, chiamate di funzione classiche in fase di Basic Measurement Feedbacktargets esecuzione, istruzioni condizionali annidate, misurazioni di circuiti intermedi e riutilizzo di qubit.

Calcolo del prodotto interno bidimensionale usando la stima della fase iterativa su tre qubit

Questo programma di esempio illustra una stima della fase iterativa all'interno di Q#. Usa la stima della fase iterativa per calcolare un prodotto interno tra due vettori 2dimensionali codificati su un target qubit e un qubit ancilla. Viene inizializzato anche un qubit di controllo aggiuntivo che sarà l'unico qubit usato per la misurazione.

Il circuito inizia codificando la coppia di vettori sul target qubit e il qubit ancilla. Applica quindi un operatore Oracle all'intero registro, controllato dal qubit del controllo, configurato nello stato $\ket +$. L'operatore Oracle controllato genera una fase sullo stato $\ket 1$ del qubit di controllo. Può quindi essere letto applicando un gate H al qubit del controllo per rendere la fase osservabile quando si misura.

Creare un progetto VS Code

1. In VS Code creare un nuovo Q# progetto di applicazione console autonomo denominato IPE.

   1. Selezionare Visualizza > pallet dei >Q#comandi : Creare una nuova applicazione console autonoma del progetto >

2. Sostituire la configurazione in IPE.csproj con quanto segue:

   <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. Sostituire il codice in Program.qs con quanto segue:

   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
   
   
   }
   

Vettori di codifica

I vettori v e c devono essere codificati nel target qubit e nel qubit ancilla. Il vettore $v = (cos(\frac{\theta_1}{2}),sin(\frac{{2}\theta_1})$ può essere rappresentato dallo stato quantistico $\ket v = cos(\frac{{2}\theta_1})\ket 0 + sin(\frac{{2}\theta_1})\ket 1$, analogamente $c$ può essere costruito usando $\theta_2$.

Rotazione Y applicata a un target qubit nello stato $\ket 0$:

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

Nota

Un fattore 2 è presente qui sullata. Un'applicazione di un gate di $RY(2\pi)$ su $\ket 0$ fornisce lo stato $-\ket 0$ e codifica il vettore $(-1,0)$. Questa fase non può essere considerata una fase globale e viene rimossa perché l'intero registro sarà intangibile.

Il registro del qubit e del target qubit ancilla è

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

Lo stato da creare è sul target qubit e il qubit ancilla è

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

che accetta anche il modulo

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

Aggiungere l'operazione seguente al file 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);
}

The Oracle

Un oracle G deve essere costruito in modo da generare un eigenphase sullo stato codificato sul target qubit e sul qubit ancilla qubit. La costruzione di questo oracle non è importante per la dimostrazione all'interno di questo esempio, ma l'operazione applicata è

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

dove il prodotto interno $\braket {v|c}$ è contenuto nella fase $\phi$, che è associato tra [0,1]. Quando applicato controllato sul qubit del controllo che inizia in questo stato $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Control }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}$$

Il qubit del controllo contiene ora la fase relativa al prodotto interno $\braket {v|c}$

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

Aggiungere l'operazione seguente al file 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);
        }
    }

Iterazione

Ora per la parte iterativa del circuito. Per n misurazioni, considerare che la fase può essere rappresentata come valore binario $\phi$e che l'applicazione di $2^n$ oracles rende il punto binario n° della fase osservabile (tramite la moltiplicazione binaria semplice e il modulo $2\pi$). Il valore del qubit del controllo può essere letto, inserito in un registro classico e la reimpostazione del qubit da usare nell'iterazione successiva. L'iterazione successiva si applica $2^{n-1}$ oracles, la fase di correzione del qubit del controllo dipende dalla misura nth. Lo stato del qubit del controllo può essere rappresentato come

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

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

L'applicazione di oracle controllati $2^n$ fornisce lo stato sul qubit del controllo

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

Si consideri che la fase non ha termini più profondi di $\phi_n$ (ad esempio, termini $\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 $$

Ora il valore $\phi_n$ può essere osservato con un cancello H e un progetto di misurazione lungo l'asse Z. Reimpostazione del qubit del controllo e applicazione dell'ora oracle $2^{n-1}$

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

Usando il valore misurato precedente per $\phi_n$, il punto binario aggiuntivo può essere ruotato

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

Questo processo viene applicato in modo iterativo per ottenere la fase $0.\phi_0\phi_1\phi_2...\phi_{n}$. Il valore viene archiviato come valore binario $x = \phi_0\phi_1\phi_2...\phi_{n}$, poiché solo gli interi sono manipolabili in fase di esecuzione.

Mentre il readout indica nulla di entrambi i vettori, solo il prodotto interno tra di loro, gli stati sul target qubit e ancilla qubit rimangono nello stesso stato durante il processo!

Aggiungere l'operazione seguente al file 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;
}

Calcolare il prodotto interno

Infine, calcolare il prodotto interno dal valore misurato

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

dove $x = \phi_0\phi_1\phi_2...\phi_{n}$. Il denominatore all'interno della funzione cosina consiste nello spostare il punto binario in modo che corrisponda al valore originale $\phi$.

Nota

Per il prodotto interno che non sono -1 o 1, le soluzioni vengono associate a una differenza di valore di $2^{n-1}$. Ad esempio, per le misurazioni n=3, il valore di bit misurato pari a 2 avrebbe anche una soluzione di coppia pari a 6. Uno di questi valori produce lo stesso valore del prodotto interno quando l'input della variabile alla funzione perfino cosine (risultante da un prodotto interno di 0 in questo esempio).

Per le soluzioni del prodotto interno tra la precisione del bit discreto, verrà prodotta una distribuzione dei risultati in base alla posizione in cui il prodotto interno si trova tra il valore di bit discreto.

Aggiungere l'operazione seguente al file 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)}");
}

Eseguire il programma

È ora possibile testare il programma. Prima di tutto, si eseguirà il programma usando un'operazione di simulazione in locale e quindi si connetterà ad Azure Quantum ed eseguirlo su un hardware target.

Simulazione della stima della fase iterativa

Q# i programmi richiedono un @EntryPoint() per indicare al compilatore dove avviare l'esecuzione del programma. Aggiungere il codice seguente a Programs.qs per avviare il programma con l'operazione SimulateInnerProduct() . Questa versione dell'operazione interna del prodotto restituisce informazioni aggiuntive, inclusa la manipolazione di doppie di cui viene visualizzato l'output nel terminale.

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

Per eseguire il programma, aprire una finestra del terminale in VS Code ed eseguire

    dotnet run

Esecuzione in un Azure Quantum target

Per eseguire su un hardware target, sostituire l'operazione con l'operazione SimulateInnerProduct() seguente HardwareInnerProduct() :

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

Connettersi quindi all'area di lavoro Azure Quantum e impostare le risorse predefinite.

az login

Nota

L'ID sottoscrizione di Azure, il gruppo di risorse e il nome dell'area di lavoro possono essere elencati nella finestra del terminale dopo l'accesso eseguendo az quantum workspace list. In alternativa, è possibile trovarli nella portale di Azure nella pagina Panoramica dell'area di lavoro Azure Quantum.

az account set --subscription <MySubscriptionID>

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

Inviare il processo con i parametri seguenti:

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

Nota

L'oggetto specificato target richiede un target profilo di esecuzione che supporta Basic Measurement Feedback.

Importante

Non è consigliabile aumentare il valore di Measurements oltre 3 durante l'esecuzione in Azure targets perché i controller di dominio completi possono aumentare in modo significativo.

È possibile visualizzare lo stato del processo con

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

sostituendo [job-id] con l'ID processo visualizzato. I risultati mostrano una soluzione nello stato con la maggioranza della popolazione. Il prodotto interno finale dei risultati integer può essere calcolato da $\braket {v|c} = -cos(2\pi x / 2^n)$, dove n è il numero di misurazioni specificate nel processo.

Nota

La selezione dei parametri di input con un solo stato della soluzione (prodotti interni di -1 o 1) è ideale per la visibilità quando si usa un numero ridotto di scatti.

Passaggi successivi

Calcolo ibrido distribuito