Eseguire processi di calcolo quantistico ibrido con profilo adattivo target

Il calcolo ibrido combina i processi di calcolo classico e quantistico per risolvere problemi complessi.

Nel calcolo ibrido, il codice classico controlla l'esecuzione di operazioni quantistiche basate su misurazioni a circuito intermedio mentre i qubit fisici rimangono attivi. È possibile usare tecniche di programmazione comuni, ad esempio istruzioni condizionali annidate, cicli e chiamate di funzione, in un singolo programma quantistico per eseguire problemi complessi, riducendo il numero di scatti necessari. Con le tecniche di riutilizzo del qubit, i programmi più grandi possono essere eseguiti in computer usando un numero minore di qubit.

Questo articolo illustra come inviare processi ibridi ad Azure Quantum usando il QIR Adaptive RItarget profilo. Il profilo dell'istanza target riservata adattiva offre il supporto per le misurazioni a metà circuito, il flusso di controllo basato sulle misure, la reimpostazione del qubit e il calcolo di interi classici.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, registrarsi gratuitamente e iscriversi per ottenere una sottoscrizione con pagamento in base al consumo.
• Un'area di lavoro di Azure Quantum. Per altre informazioni, vedere Creare un'area di lavoro di Azure Quantum.
• Per inviare Q# programmi autonomi, sono necessari i prerequisiti seguenti:
  • Visual Studio Code con l'estensione Azure Quantum Development Kit installata.
  • Versione più recente dell'estensione di AzureQuantum Development Kit.
• Se si vuole inviare Python + Q# programmi, sono necessari i prerequisiti seguenti:

  • Un ambiente Python con Python e Pip installati.

  • Azure Quantum azure-quantum e qsharp i pacchetti.

    pip install --upgrade azure-quantum qsharp
    

Aggiunta del supporto per targets

Per eseguire processi di calcolo quantistico ibrido, è necessario selezionare un provider quantistico che supporta il profilo di istanze riservate adattivetarget.

Attualmente, il profilo adattivo target in Azure Quantum è supportato in Quantinuumtargets.

Invio di processi di istanze riservate adattive

Per inviare processi di calcolo quantistico ibrido, è necessario configurare il profilo come , dove l'istanza riservata è l'acronimo di "qubit Reset e Integer computations".QIR Adaptive RItarget

Il QIR Adaptive RItarget profilo offre il supporto per le misurazioni a metà circuito, il flusso di controllo basato sulle misure, la reimpostazione del qubit e il calcolo di numeri interi classici.

È possibile inviare processi quantistici ibridi ad Azure Quantum come Q# programmi autonomi o Python + Q# programmi. Per configurare il profilo per i target processi quantistici ibridi, vedere le sezioni seguenti.

Q# in Visual Studio Code

Per configurare il profilo per i target processi ibridi in Visual Studio Code, seguire questa procedura:

1. Aprire un Q# programma in Visual Studio Code.
2. Selezionare Visualizza -> Riquadro comandi e digitare Q#: Impostare il profilo target QIR di Azure Quantum. Premere INVIO.
3. Selezionare QIR Adaptive RI.

Dopo aver impostato QIR Adaptive RI come target profilo, è possibile inviare il Q# programma come processo quantistico ibrido a Quantinuum.

1. Selezionare Visualizza -> Riquadro comandi e digitare Q#: Connettersi a un'area di lavoro di Azure Quantum. Premere INVIO.
2. Selezionare Account Azure e seguire le istruzioni per connettersi alla directory, alla sottoscrizione e all'area di lavoro preferita.
3. Dopo aver stabilito la connessione, nel riquadro Esplora risorse espandere Aree di lavoro quantistiche.
4. Espandere l'area di lavoro ed espandere il provider Quantinuum .
5. Selezionare qualsiasi Quantinuum disponibile target, ad esempio quantinuum.sim.h1-1e.
6. Selezionare l'icona di riproduzione a destra del target nome per iniziare a inviare il programma corrente Q# .
7. Aggiungere un nome per identificare il processo e il numero di scatti.
8. Premere INVIO per inviare il processo. Lo stato del processo viene visualizzato nella parte inferiore della schermata.
9. Espandere Processi e passare il puntatore del mouse sul processo, in modo da visualizzare le durate e lo stato del processo.

Q# + Python

1. Quando si usa il pacchetto Python qsharp , usare la qsharp.init funzione e impostare il target_profile parametro su Adaptive_RI.

   import qsharp
   
   qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)
   

2. Connettersi all'area di lavoro di Azure Quantum.

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

3. Impostare il target parametro su Quantinuum target da usare. Ad esempio, per usare :quantinuum.sim.h1-1etarget

   target = workspace.get_targets("quantinuum.sim.h1-1e")
   

È possibile combinare più processi quantistici ibridi all'interno di una sessione usando la target.open_session funzione . Per altre informazioni, vedere Introduzione alle sessioni.

Nota

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

Funzionalità supportate

La tabella seguente elenca le funzionalità supportate per il calcolo quantistico ibrido con Quantinuum in Azure Quantum.

Funzionalità supportata	Note
Valori di Dynamics	Valori bool e interi il cui valore dipende da un risultato di misurazione
Cicli	Solo cicli con limiti classici
Flusso di controllo arbitrario	Utilizzo di se/else diramazione
Misurazione a circuito intermedio	Usa le risorse di registrazione classiche
Riutilizzo del qubit	Supportata
Calcolo classico in tempo reale	Aritmetica dell'intero con segno a 64 bit Usa le risorse di registrazione classiche

QDK fornisce targetcommenti specifici quando Q# le funzionalità del linguaggio non sono supportate per l'oggetto selezionato target. Se il Q# programma contiene funzionalità non supportate durante l'esecuzione di processi quantistici ibridi, verrà visualizzato un messaggio di errore in fase di progettazione. Per altre informazioni, vedere la pagina wiki di QIR.

Nota

È necessario selezionare il profilo appropriato QIR Adaptive RItarget per ottenere commenti e suggerimenti appropriati quando si usano Q# funzionalità non target supportate da .

Per visualizzare le funzionalità supportate in azione, copiare il codice seguente in un Q# file e aggiungere i frammenti di codice successivi.

import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

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

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

    r0
}

Quantinuum supporta valori booleani dinamici e interi, ovvero valori booleani e interi che dipendono dai risultati della misurazione. Si noti che r0 è un Result tipo che può essere usato per generare valori bool e integer dinamici.

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

Quantinuum supporta valori bool dinamici e interi, tuttavia, non supporta valori dinamici per altri tipi di dati, ad esempio double. Copiare il codice seguente per visualizzare commenti e suggerimenti sulle limitazioni dei valori dinamici.

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

Anche se i valori dinamici non sono supportati per alcuni tipi di dati, questi tipi di dati possono comunque essere usati con valori statici.

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

Anche i valori dinamici di tipizzati supportati non possono essere usati in determinate situazioni. Ad esempio, Quantinuum non supporta matrici dinamiche, ovvero matrici le cui dimensioni dipendono da un risultato della misurazione. Quantinuum non supporta neanche i cicli delimitati dinamicamente. Copiare il codice seguente per visualizzare le limitazioni dei valori dinamici.

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

Quantinuum supporta il flusso di controllo, tra cui if/else la diramazione, usando condizioni statiche e dinamiche. La diramazione in condizioni dinamiche è nota anche come diramazione in base ai risultati della misurazione.

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

Quantinuum supporta cicli con condizioni classiche e incluse if espressioni.

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

Quantinuum supporta la misurazione a metà circuito, ovvero la diramazione in base ai risultati della misurazione.

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

Stima del costo di un processo di calcolo quantistico ibrido

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

Dopo un'esecuzione riuscita nell'emulatore:

1. Nell'area di lavoro di Azure Quantum selezionare Gestione processi.
2. Selezionare il processo inviato.
3. Nella finestra popup Dettagli processo selezionare Stima dei costi per visualizzare il numero di eHQC (crediti dell'emulatore Quantinuum) usati. Questo numero viene convertito direttamente nel numero di HQC (crediti quantistici Quantinuum) necessari per eseguire il processo nell'hardware Quantinuum.

Nota

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

Esempi di calcolo quantistico ibrido

Gli esempi seguenti sono disponibili nel Q# repository degli esempi di codice. Illustrano il set di funzionalità corrente per il calcolo quantistico ibrido.

Codice di ripetizione a tre qubit

Questo esempio illustra come creare un codice di ripetizione a tre 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.

L'esempio di codice è disponibile qui.

Stima di fase iterativa

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 bidimensionali codificati in un target qubit e un qubit ancilla. Viene inizializzato anche un qubit di controllo aggiuntivo, che è l'unico qubit usato per la misurazione.

Il circuito inizia codificando la coppia di vettori nel target qubit e il qubit ancilla. Applica quindi un operatore Oracle all'intero registro, controllato dal qubit di 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 di controllo per rendere osservabile la fase durante la misurazione.

L'esempio di codice è disponibile qui.

Nota

Questo codice di esempio è stato scritto dai membri del team di KPMG Quantum in Australia e rientra in una licenza MIT. Illustra le funzionalità espanse di e usa cicli delimitati, chiamate di funzione classiche in fase di QIR Adaptive RItargets esecuzione, istruzioni condizionali annidate, misurazioni del circuito intermedio e riutilizzo del qubit.

Contenuto correlato

• Introduzione alle sessioni