Visualizzare i diagrammi del circuito quantistico con Q#

Articolo
06/21/2024

I diagrammi di circuito quantistico sono una rappresentazione visiva delle operazioni quantistiche. Mostrano il flusso dei qubit attraverso il programma quantistico, inclusi i cancelli e le misurazioni applicati.

Questo articolo illustra come rappresentare visivamente gli algoritmi quantistici con diagrammi circuiti quantistici usando Visual Studio Code o Jupyter Notebook.

Per altre informazioni sulle convenzioni dei diagrammi di circuiti quantistici, vedere Convenzioni dei circuiti quantistici.

Prerequisiti

VS Code

La versione più recente di Visual Studio Code o aprire VS Code sul Web.
La versione più recente dell'estensione Azure Quantum Development Kit.
I pacchetti Azure Quantum qsharp e azure-quantum Python più recenti.
```
python -m pip install --upgrade qsharp azure-quantum
```

Notebook di Jupyter

La versione più recente di Visual Studio Code o aprire VS Code sul Web.
VS Code con le estensioni Azure Quantum Development Kit, Python e Jupyter installate.
I pacchetti e Azure Quantum qsharp più recenti e il ipykernel pacchetto.qsharp-widgets
```
python -m pip install --upgrade qsharp qsharp-widgets ipykernel
```

Circuiti quantistici con Visual Studio Code

Seguire questa procedura per visualizzare i circuiti quantistici dei Q# programmi in Visual Studio Code. Per altre informazioni sulle convenzioni dei diagrammi di circuiti quantistici, vedere Convenzioni dei circuiti quantistici.

Visualizzazione di diagrammi di circuito per un Q# programma

Aprire un Q# file in Visual Studio Code o caricare uno degli esempi quantistici.
Per visualizzare il circuito quantistico del Q# programma, selezionare Visualizza -> Riquadro comandi e digitare "circuito" che dovrebbe visualizzare l'opzione Q#: Mostra circuito . È anche possibile fare clic su Circuito dall'elenco dei comandi seguenti @EntryPoint().
Il circuito viene visualizzato nella finestra del Q# circuito. Ad esempio, il circuito seguente corrisponde a un'operazione che inserisce un qubit in una sovrapposizione e quindi la misura. Il diagramma del circuito mostra un registro qubit inizializzato nello stato |0⟩. Quindi, un cancello Hadamard, H, viene applicato al qubit, seguito da un'operazione di misurazione, rappresentata da un simbolo di contatore.

Visualizzazione di diagrammi di circuito per le operazioni

È possibile visualizzare il circuito quantistico per una singola Q# operazione. A tale scopo, fare clic sul pulsante Circuito nell'obiettivo del codice visualizzato sopra la dichiarazione dell'operazione.

Screenshot di Visual Studio Code che mostra come visualizzare i circuiti nel Q# riquadro circuiti dopo il debug del programma.

Visualizzazione di diagrammi di circuito durante il debug

Durante il debug di un Q# programma, è possibile visualizzare il circuito quantistico in base allo stato corrente del programma.

Selezionare il pulsante Debug dall'elenco dei comandi code lens sotto @EntryPoint().
Nella visualizzazione Esegui ed esegui debug a sinistra espandere la sezione Circuito quantistico nel riquadro Variabili per visualizzare il circuito durante l'esecuzione del programma.
È possibile eseguire il codice e impostare punti di interruzione in vari punti per visualizzare l'aggiornamento del circuito durante l'esecuzione del programma.
Il circuito quantistico corrente viene visualizzato nel Q# pannello Circuito. Questo diagramma di circuito rappresenta lo stato corrente del simulatore, ovvero i cancelli applicati fino al punto di esecuzione corrente.

Circuiti quantistici con Jupyter Notebook

Nei notebook di Jupyter è possibile visualizzare i circuiti quantistici usando il qsharp-widgets pacchetto . Questo pacchetto fornisce un widget che esegue il rendering di un diagramma di circuito quantistico come immagine SVG.

In Visual Studio Code, selezionare Visualizza > Riquadro comandi e selezionare Crea: Nuovo Jupyter Notebook.
Nella prima cella del notebook eseguire il codice seguente per importare il Q# modulo.
```
import qsharp
```

Aggiungere una nuova cella e immettere il Q# codice. Ad esempio, il codice seguente prepara uno stato bell.

%%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);

È possibile usare la dump_circuit() funzione per visualizzare un circuito quantistico in base allo stato corrente del programma. Ad esempio, il diagramma del circuito mostra due registri qubit inizializzati nello stato |0⟩. Quindi, un gate Hadamard, H, viene applicato al primo qubit. Successivamente, un gate CNOT viene applicato usando il primo qubit come controllo, rappresentato come punto e il secondo qubit come target, rappresentato come X.
```
qsharp.dump_circuit()
```
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
È possibile visualizzare i circuiti quantistici come immagine SVG usando il qsharp-widgets pacchetto . In questo caso, il gate CNOT è rappresentato come una linea che collega i due qubit, con un punto sul qubit di controllo e una croce circoscritta sul target qubit. Per altre informazioni, vedere Convenzioni dei circuiti quantistici.
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Visualizzazione di diagrammi di circuito per un'espressione di immissione

È possibile generare un diagramma circuito per qualsiasi programma con un'espressione di immissione chiamando qsharp.circuit() e passando l'espressione di voce come argomento.

Ad esempio, aggiungere una nuova cella e copiare il codice seguente, che prepara uno stato GHZ.

%%qsharp

open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Measurement;

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    H(qs[0]);
    ApplyToEach(CNOT(qs[0], _), qs[1...]);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Aggiungere una nuova cella ed eseguire il codice seguente per visualizzare il circuito. Ad esempio, preparare uno stato GHZ con 3 qubit.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Visualizzazione di diagrammi di circuito per le operazioni con qubit

È possibile generare diagrammi di circuito per qualsiasi operazione che accetta qubit o matrici di qubit. Il diagramma mostra il numero di cavi in cui sono presenti qubit di input, oltre a eventuali qubit aggiuntivi allocati all'interno dell'operazione. Quando l'operazione accetta una matrice di qubit (Qubit[]), il circuito mostra la matrice come registro di 2 qubit.

Aggiungere una nuova cella e copiare l'esempio seguente. Questo codice prepara uno stato gatto.

%%qsharp

operation PrepareCatState(register : Qubit[]) : Unit {
    H(register[0]);
    ApplyToEach(CNOT(register[0], _), register[1...]);
}

Aggiungere una nuova cella ed eseguire il codice seguente per visualizzare il circuito dell'operazione PrepareCatState .
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Condizioni che influiscono sui diagrammi di circuito

Quando si visualizzano circuiti quantistici, le condizioni seguenti possono influire sulla visualizzazione del diagramma del circuito.

Circuiti dinamici

I diagrammi di circuito vengono generati eseguendo tutta la logica classica all'interno di un Q# programma e tenendo traccia di eventuali qubit allocati o cancelli applicati. I cicli e le istruzioni condizionali sono supportati purché gestiscano solo i valori classici.

Tuttavia, i programmi che contengono cicli ed espressioni condizionali che usano i risultati della misurazione qubit sono più difficili da rappresentare con un diagramma a circuito. Ad esempio, un'espressione simile alla seguente

if (M(q) == One) {
   X(q)
}

non può essere rappresentato con un diagramma di circuito semplice, poiché i cancelli sono condizionali su un risultato di misurazione. Un circuito di questo tipo è denominato circuito dinamico .

I diagrammi di circuito possono essere generati per i circuiti dinamici eseguendo il programma nel simulatore quantistico e tracciando i cancelli quando vengono applicati. Questa modalità è denominata modalità di traccia , poiché i qubit e i gate vengono tracciati durante l'esecuzione della simulazione.

Lo svantaggio dei circuiti tracciati è che acquisiscono solo il risultato della misurazione, e le conseguenti applicazioni di cancello, per una singola simulazione. Nell'esempio precedente, se il risultato della misurazione è Zero, il cancello non viene visualizzato X nel diagramma. Un'altra esecuzione della simulazione può mostrare un circuito leggermente diverso.

Profilo di destinazione

Il profilo attualmente selezionato target influisce sulla modalità di generazione dei diagrammi di circuito. I profili di destinazione vengono usati per specificare le funzionalità dell'hardware target e le restrizioni imposte al programma quantistico.

Quando il target profilo è impostato su Unrestricted o QIR Adaptive RI, i diagrammi di circuito mostrano le operazioni quantistiche richiamate nel Q# programma. Quando il target profilo è impostato sulla base QIR, i diagrammi di circuito mostrano le operazioni quantistiche che verrebbero eseguite sull'hardware se il programma viene inviato ad Azure Quantum con questo target profilo.

Nota

Per selezionare il target profilo in VS Code, selezionare Visualizza -> Riquadro comandi e selezionareQ# : Impostare il profilo di Azure Quantum QIRtarget. È possibile selezionare QIR base, QIR Adaptive RIo unrestricted dall'elenco a discesa.
Per selezionare il target profilo in Python, chiamare qsharp.init(target_profile=qsharp.TargetProfile.Base)o qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted)qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI).

In particolare, le scomposizione di gate vengono applicate che renderebbero il circuito risultante compatibile con le funzionalità dell'hardware target . Si tratta delle stesse scomposizione che verrebbero applicate durante la generazione del codice e l'invio ad Azure Quantum.

Si consideri ad esempio il programma seguente Q# che misura un qubit e una matrice di qubit.

namespace Sample {
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation Main() : (Result, Result[]) {
        // The `M` operation performs a measurement of a single qubit in the
        // computational basis, also known as the Pauli Z basis.
        use q = Qubit();
        let result = M(q);
        Reset(q);

        // The `MeasureEachZ` operation measures each qubit in an array in the
        // computational basis and returns an array of `Result` values.
        use qs = Qubit[2];
        let results = MeasureEachZ(qs);

        return (result, results);
    }
}

Quando target il profilo è impostato su Unrestricted o QIR Adaptive RI, i controlli visualizzati sul circuito corrispondono esattamente alle operazioni quantistiche richiamate nel Q# programma.
Quando il target profilo è di base QIR, il circuito ha un aspetto diverso. Poiché il profilo targets di base non consente il riutilizzo del qubit dopo la misurazione, la misurazione viene ora eseguita su un qubit entangled. Poiché Reset l'operazione non è un gate supportato nel profilo di base, viene eliminata. Il circuito risultante corrisponde a ciò che verrebbe eseguito sull'hardware se questo programma viene inviato ad Azure Quantum con questo target profilo.

Condividi tramite