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.

Funzionalità supportate

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

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.

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.

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.

Contenuto correlato

• Introduzione alle sessioni