Progetto 4: Smorzamento di ampiezza
In questo progetto simuleremo il modello di Jaynes-Cummings, noto anche come modello generalizzato di smorzamento dell'ampiezza, e la markovianità della dinamica in funzione dell'intensità del coupling. Per ulteriori informazioni sul modello, consultare Open Quantum Systems with Qiskit.
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
import numpy as np
Per simulare il modello di Jaynes-Cummings, consideriamo un qubit come sistema ($q_0$) e un qubit aggiuntivo ($q_1$) per implementare la mappa dinamica. In altre parole, non simuliamo le dinamiche del sistema e dell’ambiente, ma solo il canale risultante sul qubit del sistema. Ciononostante, ci riferiremo a $q_1$ come al qubit dell’ambiente. Dato che l’unico parametro del canale è $c_1(t)$ (che a sua volta è parametrizzato dal tempo), il seguente circuito produce tali dinamiche:
###########################################
# Canale di smorzamento di ampiezza #
###########################################
# Quantum register
q = QuantumRegister(2, name='q')
# Quantum circuit
ad = QuantumCircuit(q)
# Canale di smorzamento di ampiezza che agisce su qubit di sistema
## Assegnazione dei qubit
system = 0
environment = 1
# Definiamo l'angolo di rotazione
theta = 0.0
# Costruiamo il circuito
ad.x(q[system])
# Notare il fattore 2 extra dovuto a come qiskit definisce gli angoli unitari
ad.cu(theta, 0.0, 0.0, 0.0, q[system], q[environment])
ad.cx(q[environment], q[system])
# Disegnamo il circuito
ad.draw(output='mpl')
Ricorda che, nel circuito qui sopra, $\theta = \arccos{c_1(t)}$ con \begin{equation} c_{1}(t)=e^{-\lambda t/2}\left[\cosh\left(\frac{\lambda t}{2}\sqrt{1-2R}\right)+\frac{1}{\sqrt{1-2R}}\sinh\left(\frac{\lambda t}{2}\sqrt{1-2R}\right)\right]. \end{equation}
def c1(R,t):
"""Dà come risultato il fattore di coerenza nel canale di smorzamento dell'ampiezza
Args:
R (float): valore di R = \gamma_0/\lambda
t (float): valore della variabile tempo
Returns:
Un numero float
"""
def amplitude_damping_channel(q, c, sys, env, R, t):
"""Dà come risultato il fattore di coerenza nel canale di smorzamento dell'ampiezza
Args:
q (QuantumRegister): il registro da usare per il circuito
c (ClassicalRegister): il registro da usare per la misura dei qubit di sistema
sys (int): indice per il qubit di sistema
env (int): indice per il qubit ambiente
R (float): valore di R = \gamma_0/\lambda
t (float): valore della variabile tempo
Returns:
Un oggetto QuantumCircuit
"""
Attività 3 (3 punti)
Scegli alcuni (almeno 2) valori di $R$. Devono esserci valori sia superiori che inferiori a $1/2$. Per ciascun valore, simula il canale di smorzamento dell'ampiezza a diversi valori di $t$ e misura la probabilità che l'atomo si trovi nello stato eccitato ($|1\rangle$) sia su un simulatore privo di rumore che su uno con rumore (ad esempio FakePerth) con mitigazione dell'errore di lettura (LocalReadoutError). Rappresenta graficamente i risultati.
#######################################
# Canale di smorzamento dell'ampiezza #
# con testimone non-M. #
#######################################
# Registro classico e quantistico
q = QuantumRegister(3, name='q')
c = ClassicalRegister(2, name='c')
# Circuito quantistico
ad = QuantumCircuit(q, c)
# Canale di smorzamento di ampiezza che agisce su qubit di sistema
# con testimone di non-Markovianità
## Assegnazione dei qubit
system = 0
environment = 1
ancilla = 2
# Definiamo l'angolo di rotazione
theta = 0.0
# Costruiamo il circuito
## stato di Bell fra sistema e ausiliare
ad.h(q[system])
ad.cx(q[system], q[ancilla])
# Canale che agisce su qubit di sistema
ad.cu(theta, 0.0, 0.0, 0.0, q[system], q[environment])
ad.cx(q[environment], q[system])
## Misura locale per il testimone
### Scelta dell'osservabile
observable = 'YY'
### Cambiamo base
if observable == 'XX':
ad.h(q[system])
ad.h(q[ancilla])
elif observable == 'YY':
ad.sdg(q[system])
ad.h(q[system])
ad.sdg(q[ancilla])
ad.h(q[ancilla])
### Misura
ad.measure(q[system], c[0])
ad.measure(q[ancilla], c[1])
# Disegnamo il circuito
ad.draw(output='mpl')
La testimonianza è data dalla probabilità di misurare il sistema e l’ausiliare nello stato $| \phi^{+} \rangle \langle \phi^{+} | = (\mathbb{I}\otimes \mathbb{I} + \sigma_{x}\otimes \sigma_ {x} - \sigma_{y}\otimes \sigma_{y} + \sigma_{z}\otimes \sigma_{z})/4$, e il circuito sopra riportato consente la misurazione delle grandezze osservabili corrispondenti.
Scrivi una funzione che restituisca, per una data grandezza osservabile testimone, $R$ e $t$, il circuito corrispondente.
Di seguito è riportata una struttura suggerita.
def amplitude_damping_channel_witness(q, c, sys, env, anc, observable, R, t):
"""Dà come risultato un QuantumCircuit che implementa il canale di smorzamento dell'ampiezza sul qubit di sistema con testimne di non-Markovianità
Args:
q (QuantumRegister): il registro da usare per il circuito
c (ClassicalRegister): il registro da usare per la misura dei qubit di sistema e ausiliari
sys (int): indice per il qubit di sistema
env (int): indice per il qubit ambiente
anc (int): indice per il qubit ausiliare
observable (str): l'osservabile da misurare. Possibili valori "XX", "YY", "ZZ"
R (float): valore di R = \gamma_0/\lambda
t (float): valore della variabile tempo
Returns:
Un oggetto QuantumCircuit
"""
Attività 5 (4 punti)
Simula la dinamica con il testimone utilizzando gli stessi valori di $R$ e $t$ dell’Attività 3. A tal fine, esegui i circuiti su un simulatore privo di rumore e su uno con rumore (ad esempio FakePerth) con mitigazione dell’errore di lettura per le tre osservabili, $\sigma_{x}\otimes \sigma_{x}$, $\sigma_{y}\otimes \sigma_{y}$ e $\sigma_{z}\otimes \sigma_{z}$, e calcola i loro valori attesi. Ciò consente di calcolare il valore del testimone come $1 + \left\langle \sigma_{x}\otimes \sigma_{x} \right\rangle - \left\langle\sigma_{y}\otimes \sigma_{y} \right\rangle + \left\langle\sigma_{z}\otimes \sigma_{z} \right\rangle)/4$. Traccia i risultati in funzione di $t$.