Bell state entanglement and CPMG pulses

[Pratik B]

Hi,

Problem setup: I am trying to simulate the effect of dynamical decoupling pulses (specifically, CPMG ) on the entanglement of Bell state (|00>+|11>)/sqrt(2). My aim is to see how effectively the CPMG scheme (essentially, series of equispaced pi-pulses) preserves the entanglement of the Bell state exposed to dephasing noise. I consider simple model of photonic qubits under two-mode free-hamiltonian and dephasing noise and then plot concurrence (measure of entanglement) of the system. I compare 3 cases: (i) Ideal case i.e no dephasing, no pulses (ii) bell state affected by dephasing noise (iii) bell state + dephasing noise + CPMG pi-pulses. Please see attached image of resulting plots of concurrence & fidelity for these 3 cases.

Question:

(1) I do see 'kind' of advantage of CPMG pulses in the sense that entanglement dissipation is slowed down but I am not sure how to interpret the oscillation of concurrence aka entanglement. I was expecting a smooth dissipation curve for pulsed case because how can the amount of entanglement revive to C=~0.8 after it has dropped to C=~0.2? Also, this advantage is very fickle and sensitive to values of code parameters like omega, pulse_strength, t_span etc.

(2) Also, Is there any other efficient way to simulate this problem?

My code:

psi0 = bell_state(state='00').unit()
a1 = tensor(destroy(2), qeye(2)) # mode annihilation operators for both modes
a2 = tensor(qeye(2), destroy(2))
hbar = 1
omega = 4.0 #(arbitrary)
Tmax = 4  #Total duration of simulation
Nmax = 800  # Number of time steps
#============= Pulse setup ==============
pulse_strength = 3.0  #(arbitrary)
delta = 0.05  # pulse bandwidth
t_span = np.linspace(0.0, Tmax, Nmax)
def Gaussian(t, t0):
    return  1.0*np.exp(-(t - t0)**2.0/(delta ** 2.0))
tau = 0.0  #time of the first pulse
inc = 0.15
pulse1 = np.zeros(Nmax,int)
pulse1 = Gaussian(t_span, tau)
pulse2 = np.zeros(Nmax,int)
pulse2 = Gaussian(t_span, tau+inc)
pulse3 = np.zeros(Nmax,int)
pulse3 = Gaussian(t_span, tau+2*inc)
pulse4 = np.zeros(Nmax,int)
pulse4 = Gaussian(t_span, tau+3*inc)
pulse5 = np.zeros(Nmax,int)
pulse5 = Gaussian(t_span, tau+4*inc)
pulse6 = np.zeros(Nmax,int)
pulse6 = Gaussian(t_span, tau+5*inc)
pulse7 = np.zeros(Nmax,int)
pulse7 = Gaussian(t_span, tau+6*inc)
pulse8 = np.zeros(Nmax,int)
pulse8 = Gaussian(t_span, tau+7*inc)
pulse9 = np.zeros(Nmax,int)
pulse9 = Gaussian(t_span, tau+8*inc)
pulse10 = np.zeros(Nmax,int)
pulse10 = Gaussian(t_span, tau+9*inc)
#======== ========= mesolve parameters ========================
H0 = hbar * omega * (a1.dag() * a1 + a2.dag() * a2)   # Two-mode free Hamiltonian
H1 = tensor(pulse_strength*sigmax(), pulse_strength*sigmax()) #Pi-pulse (about X-axis)
H = [H0,[H1, pulse1],[H1, pulse2],[H1, pulse3],[H1, pulse4],[H1, pulse5],[H1, pulse6],
     [H1, pulse7],[H1, pulse8],[H1, pulse9],[H1, pulse10]]    # time-dependent total H
kappa = 0.5  #dephasing rate (arbitrary)
x1_x2 = tensor(sigmax(),sigmax()) # combined X operator for both qubits
z1_z2 = tensor(sigmaz(),sigmaz()) # combined Z operator for both qubits
deph1 = tensor(sigmaz(), qeye(2)) # Dephasing for 1st qubit
deph2 = tensor(qeye(2), sigmaz()) # Dephasing for 2nd qubit
c_ops = [kappa * deph1, kappa* deph2]
e_ops = [x1_x2, a1.dag() * a1, z1_z2]
opts = qutip.Odeoptions(store_states=True)
result0 = mesolve(H0, psi0, t_span, [], e_ops, options=opts) #no deph., no pulses
result1 = mesolve(H0, psi0, t_span, c_ops, e_ops, options=opts) #deph., no pulses
result2 = mesolve(H, psi0, t_span, c_ops, e_ops, options=opts) #deph., 10 pulses

Thanks & regards,

Pratik

[Simon Cross]

Hi Pratik,

We have a worked example on using the HEOM to simulate dynamic decoupling at https://nbviewer.org/github/qutip/qutip-notebooks/blob/master/examples/heom/heom-4-dynamical-decoupling.ipynb.

In general one cannot simulate dynamic decoupling with only a memory-less bath.

Regards,

Simon

[Pratik B]

Thank you so much for your reply Simon! I will check out the linked Python notebook.

Regards,

Pratik

[Pratik B]

Hi Simon,

I forgot to bring up this point earlier. The reason I thought I can do this simulation of dynamical decoupling with mesolve was this paper:

https://iopscience.iop.org/article/10.1088/1674-1056/28/6/060201/pdf where authors have done it for a qubit evolution under CP decoupling pulses.

Regards,

Pratik

--
You received this message because you are subscribed to a topic in the Google Groups "QuTiP: Quantum Toolbox in Python" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/qutip/iGF96squ1Hk/unsubscribe.
To unsubscribe from this group and all its topics, send an email to qutip+un...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/qutip/CAD5NRCHtQyKX2JoLzjcVBAmzOFzrWGnNVZHW%2BkWyH-_Rq6n6OA%40mail.gmail.com.

--

Regards,

Pratik

[Neill Lambert]

hi pratik,

just to chip in, quickly looking at that paper the noise they decouple is 1/f noise they include as a random but time-correlated term in the hamiltonian, to quote the paper:

" For decoupling sequences to work, the noise in a control cycle should be correlated in some way. 1/f noise is coherent noise and has quite a long correlation time, which makes it perfect for the demonstration of DD."

As simon mentioned, noise arriving from static lindblads typically cannot be decoupled with DD.

In your code, it looks like your entanglement increases under the pulses because the pulses are products of sigma_x terms on both qubits, so are effectively entangling operations.  

all the best

neill

You received this message because you are subscribed to the Google Groups "QuTiP: Quantum Toolbox in Python" group.
To unsubscribe from this group and stop receiving emails from it, send an email to qutip+un...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/qutip/CAFS7uCcYCr0_hE%2BKofhKLjOFCgbq2A%2ByCCNXx6tn1CWuCpvmxA%40mail.gmail.com.

--

-----------------------------------
Senior Research Scientist
RIKEN, Japan
Research Homepage

[Pratik B]

Hi Neill,

Thank you for pointing out this important distinction! So, noise needs to be time-correlated to yield itself to DD and the code that I posted here has a constant kappa ('dephasing rate' term in the lindbladian) which is why DD pulses are not working as expected. Is my understanding correct? And does that mean I can simulate my system using mesolve (as done in above mentioned paper) instead of HEOM if it has time-correlated noise?

I am not an expert QuTiP user so I didn't quite understand the equivalence of Simon's statement: one cannot simulate dynamic decoupling with only a memory-less bath and your statement: noise arriving from static lindblads typically cannot be decoupled with DD. Could you please elaborate on this a little?

Regards

Pratik

To view this discussion on the web visit https://groups.google.com/d/msgid/qutip/CAKKp-tOXCUH9DXOMpt%2BSfLPW2_o8Aq%2B74tppRQ-TthGrWKJT8A%40mail.gmail.com.

--

Regards,

Pratik

[Neill Lambert]

hi pratik,

Thank you for pointing out this important distinction! So, noise needs to be time-correlated to yield itself to DD and the code that I posted here has a constant kappa ('dephasing rate' term in the lindbladian) which is why DD pulses are not working as expected. Is my understanding correct? And does that mean I can simulate my system using mesolve (as done in above mentioned paper) instead of HEOM if it has time-correlated noise?

I believe so, if you can model that time-correlated noise as a random hamiltonian term as they do in that paper, though I have never done this myself, and it wasn't very clear to me precisely how they average over that type of noise.

 

I am not an expert QuTiP user so I didn't quite understand the equivalence of Simon's statement: one cannot simulate dynamic decoupling with only a memory-less bath and your statement: noise arriving from static lindblads typically cannot be decoupled with DD. Could you please elaborate on this a little?

Typically Lindblad master equations with positive rates can be derived by starting from a system-bath model and applying Born and Markov assumptions. The latter is normally said to be an approximation that means the bath has no memory. One example is to directly assume the bath correlation functions are delta-correlated in time.  I believe that in these cases DD doesn't work because you typically need to apply the pulses faster than the bath memory time. A different way to see it is that DD works when the dephasing that occurs is really like a ''coherent'' drift on some time scale that can be undone by applying the pulse and allowing the qubit to experience the reverse evolution of that drift on the opposite side of the bloch sphere. if that noise is completely random at each time step, then, as far as i know, DD usually doesn't work.

However, there may be other forms of lindblads with time-dependent or negative rates which correspond to some kind of non-markov noise. But it's also something I haven't played with much, maybe someone else with more experience can comment on those combined with dynamical decoupling methods.

caveat:  my experience with DD methods is not very broad, so please take the above with a grain of salt :)  I have some recollection of previous discussions of this kind of thing in the mailing list, it might be worth searching a bit.

all the best

neill

[Pratik B]

Neill,

Thank you for your detailed response!

In case you are interested, there is brief description of 1/f noise generation in Appendix B of the paper.

Regards,

Pratik