Come creare modelli di disturbo per le simulazioni quantistiche in QDK

Microsoft Quantum Development Kit (QDK) include un set di simulatori quantistici che modellano il modo in cui il programma viene eseguito in un computer quantistico. I programmi eseguiti in un computer quantistico includono sempre un certo tipo e grado di rumore. Il QDKPython pacchetto consente di creare modelli di rumore personalizzati da usare nelle simulazioni tramite l'API NoiseConfig .

Per istruzioni su come installare e usare i QDK simulatori, vedere Come installare ed eseguire i QDK simulatori quantistici.

Tipi di rumore

Ogni operazione o istruzione in un programma quantistico può introdurre rumore. Nella tabella seguente sono elencate tutte le operazioni e le istruzioni per cui è possibile impostare il rumore.

Sorgente di rumore	Parametro del modello di rumore	Descrizione origine
porta $X$	`x`	Porta di Pauli a qubit singolo, inversione di bit
porta $Y$	`y`	Gate Pauli a singolo qubit, capovolgimento bit e capovolgimento delle fasi
porta $Z$	`z`	Gate Pauli a singolo qubit, capovolgimento delle fasi
porta $H$	`h`	Porta Hadamard a singolo qubit, crea lo stato di sovrapposizione uguale
porta $S$	`s`	Porta a qubit singolo, inversione di fase di π/2
$S^\dagger$ porta	`s_adj`	Gate a qubit singolo, adiacente di $S$
porta $T$	`t`	Porta a qubit singolo, labbro di fase π/4
$T^\dagger$ porta	`t_adj`	Gate a qubit singolo, adiacente di $T$
porta $S_X$	`sx`	Gate a qubit singolo, capovolgimento a metà bit
porta $S_X^\dagger$	`sx_adj`	Gate a qubit singolo, adiacente di $S_X$
porta $R_X$	`rx`	Gate a qubit singolo, rotazione generale delle fasi circa l'asse $x$
porta $R_Y$	`ry`	Gate a qubit singolo, rotazione generale delle fasi circa l'asse $y$
gate $R_Z$	`rz`	Gate a qubit singolo, rotazione generale delle fasi sull'asse $z$
porta $CX$	`cx`	Porta a due qubit, porta controllata-$X$
porta $CY$	`cy`	Porta a due qubit, porta controllata-$Y$
$CZ$ porta	`cz`	Porta a due qubit, porta $Z$ controllata
porta $R_{XX}$	`rxx`	Gate a due qubit, analogo a $R_X$
porta $R_{YY}$	`ryy`	Gate a due qubit, analogo a $R_Y$
porta $R_{ZZ}$	`rzz`	Gate a due qubit, analogo a $R_Z$
$SWAP$ porta	`swap`	Gate a due qubit, scambia gli stati dei qubit
porta $CCX$	`ccx`	Porta a tre qubit, porta controllata-$X$ a due qubit
Spostamento qubit	`mov`	Spostamento di qubit tra le zone del dispositivo (per la simulazione di un dispositivo a atomi neutri)
Misurazione del qubit	`mz`	Misurazione a qubit singolo nella base pauli-$Z$
Misurazione e reimpostazione del qubit	`mresetz`	Misurazione a qubit singolo e reimpostazione dello stato 0

Con NoiseConfigè possibile applicare quattro diversi tipi di rumore alle operazioni precedenti con probabilità specifiche. Nella tabella seguente sono elencati i parametri del tipo di rumore che è possibile impostare con NoiseConfig, incluso un parametro per nessun rumore.

Tipo di rumore	Parametro del modello di rumore	Descrizione del rumore	Esempio di utilizzo	Descrizione esempio
Pauli $X$ rumore	`x`	Inversione di bit	`noise.z.x = 0.03`	Si verifica un'inversione di bit nel 3% delle operazioni $Z$
Pauli $Y$ rumore	`y`	Capovolgimento di bit e capovolgimento delle fasi	`noise.sx.y = 0.01`	Flip bit e flip di fase si verificano nel 1% delle operazioni $S_X$
Pauli Z rumore	`z`	Capovolgimento della fase	`noise.h.z = 0.02`	Si verifica un’inversione di fase nel 2% delle operazioni $H$
Nessun rumore	`i`	Operazione di identità, nessun effetto	`noise.cz.ix = 0.02`	L'inversione di bit solo sul qubit di destinazione avviene nel 2% delle operazioni $CZ$
Perdita di qubit	`l`	Il qubit è stato perso dal dispositivo	`noise.mov.l = 0.03`	Qubit perso nel 3% degli spostamenti tra le zone del dispositivo in un computer quantistico ad atomi neutri

Il rumore si verifica dopo l'operazione di origine, non anziché l'operazione di origine. Ad esempio, noise.z.x significa che il programma applica il gate $Z$ previsto al qubit e quindi applica un gate $X$ non previsto al qubit. Poiché il rumore si applica dopo la sorgente, è possibile configurare il rumore che ha lo stesso effetto della sorgente. Ad esempio, noise.x.x applica un'inversione di bit non intenzionale dopo l'inversione di bit desiderata.

Note

Le API per la simulazione di dispositivi a atomi neutri supportano il rumore proveniente da un numero limitato di fonti. Per ulteriori informazioni, vedere Come creare modelli di rumore per le simulazioni di dispositivi ad atomi neutri nel QDK.

Creare un modello di rumore

Per creare un modello di rumore per una simulazione e visualizzare gli effetti di tale rumore sui risultati del programma quantistico, seguire questa procedura.

In VS Codeaprire il menu Visualizza e scegliere Riquadro comandi.
Immettere Crea: Nuovo Jupyter Notebook. Un file vuoto Jupyter Notebook viene aperto in una nuova scheda.

Nella prima cella del notebook importare gli oggetti necessari Python .

from qdk import init, TargetProfile
from qdk.openqasm import compile
from qdk.simulation import NoiseConfig, run_qir
from qdk.widgets import Histogram

In una nuova cella impostare il profilo di destinazione QIR del dispositivo e compilare il circuito OpenQASM in QIR.

init(target_profile=TargetProfile.Base)

qasm_src = """
include "stdgates.inc";
qubit[2] qs;
bit[2] r;

h qs[0];
cx qs[0], qs[1];
r = measure qs;
"""

qir = compile(qasm_src)

Creare un NoiseConfig oggetto e creare il modello di rumore.
```
noise = NoiseConfig()

noise.h.x = 0.01
noise.cx.zi = 0.02
```
Questo codice produce il modello di rumore seguente, in cui la frequenza del rumore è la probabilità che l'origine causi il tipo di rumore corrispondente.

Sorgente di rumore Tipo di rumore Tasso di rumore

porta $H$ Inversione di bit 1%

porta $CX$ Inversione della fase sul qubit di controllo 2%
Eseguire il simulatore con il modello di rumore e visualizzare un istogramma dei risultati della misurazione. Ad esempio, eseguire il codice seguente per simulare 1.000 scatti del programma nel simulatore Clifford.
```
results = run_qir(qir, shots=1000, noise=noise, type="clifford")
Histogram(results, labels="kets")
```
Per confrontare i risultati rumorosi con una simulazione senza rumore, eseguire di nuovo la simulazione senza alcun modello di rumore.
```
results = run_qir(qir, shots=1000, type="clifford")
Histogram(results, labels="kets")
```

Sorgente di rumore	Tipo di rumore	Tasso di rumore
porta $H$	Inversione di bit	1%
porta $CX$	Inversione della fase sul qubit di controllo	2%

Impostare più tipi di rumore sulla stessa sorgente

È possibile modellare diversi tipi di rumore sulla stessa fonte, con probabilità diverse per ogni tipo di rumore. Ad esempio, il codice seguente imposta una probabilità dell'1% che si verifichi un'inversione di bit e una probabilità del 3% che si verifichi un'inversione di fase dopo una porta Hadamard.

noise.h.x = 0.01
noise.h.z = 0.03

Quando si configurano più tipi di rumore per la stessa operazione, è possibile applicare un solo tipo di rumore a ogni operazione nel programma. Ad esempio, ogni porta di Hadamard può avere rumore $X$ o rumore $Z$, ma non entrambi.

Funzioni del modello di rumore

Invece di parametri del modello di rumore, è possibile usare il set seguente di funzioni di rumore per creare il tuo modello di rumore.

Impostare il rumore di Pauli

Per includere il rumore Pauli nel modello, chiamare la funzione set_pauli_noise su un gate o un'operazione di spostamento.

Per le operazioni a qubit singolo, passare una stringa Pauli di un carattere e una frequenza di rumore. Ad esempio, il codice seguente imposta una probabilità dell'1% che si verifichi un'inversione di bit durante lo spostamento del qubit.

# Equivalent to: noise.mov.x = 0.01
noise.mov.set_pauli_noise('X', 0.01)

Per le operazioni a due qubit, specificare una stringa di Pauli di due caratteri e un tasso di rumore. Il primo carattere della stringa Pauli corrisponde al rumore sul qubit di controllo e il secondo carattere corrisponde al rumore nel qubit di destinazione. Ad esempio, il codice seguente imposta inversioni di fase correlate nel 1% delle operazioni $CX$.

# Equivalent to: noise.cx.zz = 0.01
noise.cx.set_pauli_noise('ZZ', 0.01)

Impostare il rumore depolarizzato

La set_depolarizing funzione imposta frequenze di rumore uguali ma non correlate per tutti e tre i tipi di rumore Pauli. Ad esempio, il codice seguente imposta una probabilità del 3% che si produca rumore di Pauli dopo un'operazione $H$, distribuita equamente in una probabilità dell'1% per ciascuno dei tre tipi di rumore di Pauli.

# Equivalent to:
#     noise.h.x = 0.01
#     noise.h.y = 0.01
#     noise.h.z = 0.01
noise.h.set_depolarizing(0.03)

Impostare il rumore di inversione di bit

Per impostare la frequenza di rumore per i capovolgimenti di bit, utilizzare la funzione set_bitflip su una porta o un'operazione di movimento. Ad esempio, il codice seguente imposta una probabilità dell'1% che si verifichi un'inversione di fase dopo un'operazione $R_Z$.

# Equivalent to: noise.rz.x = 0.01
noise.rz.set_bitflip(0.01)

Impostare il rumore di inversione di fase

Per impostare il tasso di rumore per i capovolgimenti di fase in un'operazione, usare la funzione set_phaseflip su un gate o un'operazione di spostamento. Ad esempio, il codice seguente imposta un% probabilità che si verifichi un capovolgimento di una fase dopo un'operazione $R_Y$.

# Equivalent to: noise.ry.z = 0.01
noise.ry.set_phaseflip(0.01)

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-08-18