In questo progetto implementeremo il canale di depolarizzazione in Qiskit e lo testeremo con la tomografia di stato su un simulatore e, facoltativamente, su un dispositivo reale.
Il canale di depolarizzazione è uno dei modelli più comuni di decoerenza dei qubit grazie alle sue interessanti proprietà di simmetria. Possiamo descriverlo affermando che, con probabilità $1-p$ il qubit rimane intatto, mentre con probabilità $p$ si verifica un errore. L'errore può essere un errore di inversione di bit, descritto dall'azione di $\sigma_x$, un errore di inversione di fase, descritto dall'azione di $\sigma_z$, o entrambi, descritti dall'azione di $\sigma_y$. La mappa dinamica di un sistema quantistico aperto markoviano soggetto a rumore depolarizzante può essere scritta come
\begin{align} \Phi_t \rho_S = \left[1-\frac 3 4 p(t)\right] \rho_S + \frac{p(t)}{4} \sum_i \sigma_i \rho_S \sigma_i, \end{align}dove $i=x,y,z$ e $p(t)=1 - e^{-\gamma t}$, con $\gamma$ il rate di decadimento di Markov.
Il canale di depolarizzazione può essere implementato, per qualsiasi valore di $p\equiv p(t) \in [0, 1]$, con il circuito illustrato nella figura sopra. Tre qubit ausiliari vengono preparati in uno stato $| \psi_\theta \rangle = \cos \theta/2 | 0 \rangle + \sin \theta/2 | 1 \rangle$ e vengono utilizzati come controlli rispettivamente per una rotazione controllata-$X$ (CNOT), una rotazione controllata-$Y$ e una rotazione controllata-$Z$. In questo modo, ogni gate verrà applicato con una probabilità di $\sin^2 \theta/2$.
L'angolo di rotazione $\theta$ deve essere scelto in modo tale che ciascuno dei gate venga applicato con probabilità $p$. Si noti che applicare prima $X$ e poi $Y$, senza applicare $Z$, equivale (a parte le fasi globali) ad applicare solo $Z$, e così via. L'equazione risultante che lega $\theta$ a $p$ è quindi
\begin{equation} \sin^2 \frac \theta 2 \cos^4\frac\theta2 + \sin^4 \frac\theta 2 \cos^2 \frac \theta 2 = \frac p 4, \end{equation}con soluzione $\theta(p) = \frac 12 \arccos(1 - 2 p)$.
####################################
# Canale di depolarizzazione #
####################################
from qiskit import QuantumRegister, QuantumCircuit
import numpy as np
# Quantum register
q = QuantumRegister(4, name="q")
# Quantum circuit
depolarizing = QuantumCircuit(q)
# Canale di depolarizzazione che agisce su q_0
## Identificazione di qubit
system = 0
a_0 = 1
a_1 = 2
a_2 = 3
## Definire l'angolo di rotazione
theta = np.pi/4
## Costruire il circuito
depolarizing.ry(theta, q[a_0])
depolarizing.ry(theta, q[a_1])
depolarizing.ry(theta, q[a_2])
depolarizing.cx(q[a_0], q[system])
depolarizing.cy(q[a_1], q[system])
depolarizing.cz(q[a_2], q[system])
# Disegnare il circuito
depolarizing.draw(output='mpl')
def depolarizing_channel(q, p, system, ancillae):
"""Dà come risultato un QuantumCircuit che implementa il canale di depolarizzazione su q[sistema]
Args:
q (QuantumRegister): il registro da usare per il circuito
p (float): la probabilità per il canale fra 0 e 1
system (int): indice del qubit di sistema
ancillae (list): lista di indici per i qubit ausilirari
Returns:
Un oggetto QuantumCircuit
"""
# Scrivi il codice qui...
# Fissiamo il registro quantistico e l'assegnazione dei qubit
# Creiamo il circuito quantistico
q = QuantumRegister(4, name='q')
# Indice del qubit di sistema
system = 1
# Indici dei qubit ausiliari
ancillae = [0, 2, 3]
Attività 3 (4 punti)
Preparare l'esperimento di tomografia di stato con cui analizzeremo lo stato generato dal circuito e dal rumore depolarizzante. In questo caso, ricostruiremo le matrici di densità e le fidelità di stato.
Per diversi valori di $p \in [0, 1]$:
Combina
initial_stateedepolarizing_channelin un circuito.Prepara ed esegui
StateTomographydaqiskit_experiments.library.tomographyper eseguire la tomografia solo sul qubit di sistema utilizzando un simulatore.Calcola anche la fedeltà rispetto allo stato del qubit di sistema in
initial_state(senza il canale di depolarizzazione). Potrebbe essere necessariopartial_tracedaqiskit.quantum_info.Calcolare le barre di errore per le fedeltà con il bootstrapping). A tal fine, utilizzare
StateTomographyAnalysisdaqiskit_experiments.library.tomographycon alcuni argomenti e fornirlo aStateTomography.
Raccogli le matrici di densità, le fedeltà e gli errori delle fedeltà.
- Descrivi brevemente con parole tue cosa fa
StateTomography. Cosa bisogna misurare? Come ci assicuriamo che la matrice di densità sia fisica? (Tomografia dello stato quantistico nella documentazione diqiskit-experimentse Sistemi quantistici aperti con Qiskit potrebbero essere d'aiuto. )
# Per esempio, consideriamo 10 valori di p spaziati ugualmente
import numpy as np
p_values = np.linspace(0, 1, 10)
Attività 4 (4 punti)
- Calcola numericamente la matrice di densità esatta del qubit del sistema dopo il canale di depolarizzazione in funzione di $p$.
- Traccia i valori di $\rho_{00}$, $\rho_{11}$, $\mathrm{Re}(\rho_{01})$, $\mathrm{Im}(\rho_{01})$ in funzione di $p$ e confrontali con la previsione analitica.
- Trova numericamente le fedeltà esatte del qubit del sistema dopo il canale di depolarizzazione in funzione di $p$.
- Traccia sia le fedeltà esatte che quelle simulate del qubit del sistema rispetto allo stato iniziale del sistema in funzione di $p$. Aggiungi ai grafici le barre di errore calcolate nell'attività 3.
Fatti salvi gli errori statistici dovuti al numero finito di shot, i punti simulati dovrebbero essere vicini alla previsione analitica. Per la fedeltà, le barre di errore coprono 1 deviazione standard (~68%).
import matplotlib.pyplot as plt
Attività facoltativa
Esegui tutte le attività su un dispositivo reale con mitigazione del rumore e confronta i risultati con quelli della simulazione. A tal fine puoi utilizzare MitigatedStateTomography invece di StateTomography.
Si noti che MitigatedTomographyAnalysis funziona in modo leggermente diverso da StateTomographyAnalysis. In caso di problemi, provare a specificare la classe di analisi al momento dell'esecuzione dell'esperimento di tomografia, anziché durante l'inizializzazione.
Inoltre, è possibile ottenere il backend del dispositivo reale utilizzando il codice seguente (le primitive come Sampler sono relativamente nuove, quindi non sono ancora supportate in qiskit-experiments). Infine, assicurati di aver creato e salvato il tuo account IBM Quantum!
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
# Sostitusci ibm_brisbane con il backend su cui vuoi eseguire
backend = service.get_backend("ibm_brisbane")