Search
Progetto 1: Canale di depolarizzazione

Progetto 1: Canale di depolarizzazione

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')
---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[1], line 5
      1 ####################################
      2 #       Depolarizing channel       #
      3 ####################################
----> 5 from qiskit import QuantumRegister, QuantumCircuit
      6 import numpy as np
      8 # Quantum register

ModuleNotFoundError: No module named 'qiskit'

Attività 1 (1 punto)

Crea una funzione che dia come risultato un circuito quantistico che implementi un canale di depolarizzazione con parametro $p$ su uno specifico system di qubit, usando tre qubit ausiliari ancillae = [a1, a2, a3].

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...

Attività 2 (1 punto)

Scrivi uno stato iniziale (initial_state) per un circuito che prepari il system qubit in uno stato iniziale con popolazioni e coerenze non nulle (parti reali e immaginarie)

# 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.

  1. Per diversi valori di $p \in [0, 1]$:

    1. Combina initial_state e depolarizing_channel in un circuito.

    2. Prepara ed esegui StateTomography da qiskit_experiments.library.tomography per 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 necessario partial_trace da qiskit.quantum_info.

      • Calcolare le barre di errore per le fedeltà con il bootstrapping). A tal fine, utilizzare StateTomographyAnalysis da qiskit_experiments.library.tomography con alcuni argomenti e fornirlo a StateTomography.

    3. Raccogli le matrici di densità, le fedeltà e gli errori delle fedeltà.

  2. 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 di qiskit-experiments e 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)

  1. Calcola numericamente la matrice di densità esatta del qubit del sistema dopo il canale di depolarizzazione in funzione di $p$.
  2. 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.
  3. Trova numericamente le fedeltà esatte del qubit del sistema dopo il canale di depolarizzazione in funzione di $p$.
  4. 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")