Demo for the circuit processor and the effect of noise for simple quantum gates

Example for spin chain and cqed model

Example for spin chain and cqed model

In [1]:
%matplotlib inline
from qutip import *
from qutip.qip.models.spinchain import *
from qutip.qip.models.circuitprocessor import *
from qutip.qip.models.cqed import *
In [2]:
N = 3
qc = QubitCircuit(N)
qc.add_gate("CNOT", targets=[0], controls=[2])

Spinchain model

This module takes a quantum circuit and find a pulse sequence generating the circuit with the Hamiltonian realsized by the spinchain model.

It first resolves the gate into the following gates : "GLOBALPHASE", "ISWAP", "RX", "RZ" and then genearte a time-dependent hamitonian sequence consisting of $\sigma_{x}$, $\sigma_{z}$ and $\sigma_{x}\sigma_{x}+\sigma_{y}\sigma_{y}$

In [3]:
lsc = LinearSpinChain(N, correct_global_phase=True)

# create pulse sequences
U_list = lsc.run(qc)
In [4]:
# resolved gates from "ISWAP", "RX", "RZ" 
lsc.qc2.gates
Out[4]:
[Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(ISWAP, targets=[0, 1], controls=None),
 Gate(RX, targets=[0], controls=None),
 Gate(ISWAP, targets=[0, 1], controls=None),
 Gate(RX, targets=[1], controls=None),
 Gate(ISWAP, targets=[1, 0], controls=None),
 Gate(RX, targets=[0], controls=None),
 Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(ISWAP, targets=[2, 1], controls=None),
 Gate(RZ, targets=[1], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RX, targets=[2], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(ISWAP, targets=[2, 1], controls=None),
 Gate(RZ, targets=[1], controls=None),
 Gate(RX, targets=[1], controls=None),
 Gate(RZ, targets=[1], controls=None),
 Gate(RZ, targets=[1], controls=None),
 Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(ISWAP, targets=[0, 1], controls=None),
 Gate(RX, targets=[0], controls=None),
 Gate(ISWAP, targets=[0, 1], controls=None),
 Gate(RX, targets=[1], controls=None),
 Gate(ISWAP, targets=[1, 0], controls=None),
 Gate(RX, targets=[0], controls=None)]
In [5]:
lsc.plot_pulses();

CQED model

The state is represented by a resonator mode of $N_{res}$ levels and qubits states of $N$ levels. The availabel Hamitonian is $\sigma_x$, $\sigma_z$ and the qubit-cavity interaction $a^\dagger \sigma^- + a \sigma^+$.

In [6]:
qc = QubitCircuit(N)
qc.add_gate("CNOT", targets=[0], controls=[2])
# qc.add_gate("SWAP", targets=[0,2])
cqed = DispersivecQED(3)
U_list = cqed.run(qc)

Resolved gate sequence from "ISWAP", "RX", "RZ". It is a bit different compared to linear spin chain because of boundary conditions

In [7]:
cqed.qc2.gates
Out[7]:
[Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(ISWAP, targets=[2, 0], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RZ, targets=[0], controls=None),
 Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(RZ, targets=[0], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RX, targets=[2], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(ISWAP, targets=[2, 0], controls=None),
 Gate(RZ, targets=[2], controls=None),
 Gate(RZ, targets=[0], controls=None),
 Gate(GLOBALPHASE, targets=None, controls=None),
 Gate(RZ, targets=[0], controls=None),
 Gate(RX, targets=[0], controls=None),
 Gate(RZ, targets=[0], controls=None),
 Gate(RZ, targets=[0], controls=None)]
In [8]:
cqed.plot_pulses();
In [ ]:
Demonstration of noise

Demostration of noise in the control

Hadamard gate

In [1]:
from qutip import *
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import normal as gauss
pi = np.pi

Hadamard gate can be generated by Hamiltonian $\sigma_y$ and a $\sigma_z$ for time $t_1$ and $t_2$

$u = \exp[-i\sigma_z t_2]\cdot\exp[-i\sigma_y t_1]$

In [2]:
H1 = sigmay()
H2 = sigmaz()
t1 = 3./4.*pi
t2 = 1./2.*pi
up = basis(2,0)

This can be proved by explicit calculation

In [3]:
u1 = (-1.j * t1 * H1).expm()
u2 = (-1.j * t2 * H2).expm()
u = u2*u1
u
Out[3]:
Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}0.707j & 0.707j\\0.707j & -0.707j\\\end{array}\right)\end{equation*}

Now we use mesolve to calculate the state evolution under these two pulses and vary $t_1$ for Hamiltonian $\sigma_z$. We start from $|{\uparrow}>$ and should get $|+>$ if $t=t_1$

In [4]:
def noisy_Hadamard(t1):
    iter_num = 50

    rho0 = basis(2,0)
    tlist = np.linspace(0,t1,iter_num)
    H = [[H1, np.ones(iter_num)]]
    result = mesolve(H, rho0, tlist)

    rho1 = result.states[-1]
    tlist = np.linspace(0,t2-0.03,iter_num)
    H = [[H2, np.ones(iter_num)]]
    result = mesolve(H, rho1, tlist)
    
    return result.states[-1]
In [5]:
t1_line = np.linspace(0.8*t1,1.2*t1,30)
plus = (basis(2,0)+basis(2,1)).unit()
F_line = list(map(lambda t1: fidelity(noisy_Hadamard(t1), plus), t1_line))

We plot the fidelity as a function of $t/t_1$

In [6]:
plt.plot(t1_line/t1, F_line)
plt.xlabel("$t'/t_1$")
plt.ylabel("Fidelity");

CNOT gate

We do the same for CNOT gate. We assume here that all the single qubit operations are perfect and only the two qubit interaction is noisy.

In [7]:
t = pi/8
# two qubits interaction
H = (tensor(sigmax(),identity(2)) + tensor(identity(2),sigmax()))**2
u = (-1.j*t*H).expm()
snot12 = tensor(snot(),snot())
snot1 = tensor(snot(),identity(2))
snot2 = tensor(identity(2),snot())
snot1* u * snot12 * tensor(rz(-pi/2),rz(-pi/2)) * snot2
Out[7]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = True\begin{equation*}\left(\begin{array}{*{11}c}1.000 & 0.0 & 0.0 & 0.0\\0.0 & 1.000 & 0.0 & 0.0\\0.0 & 0.0 & 0.0 & 1.000\\0.0 & 0.0 & 1.000 & 0.0\\\end{array}\right)\end{equation*}
In [8]:
def noisy_CNOT(t):
    iter_num = 50
    rho = tensor(basis(2,1),basis(2,0))
    rho = snot12 * tensor(rz(-pi/2),rz(-pi/2)) * snot2 * rho
    tlist = np.linspace(0,t,iter_num)
    result = mesolve([[H, np.ones(iter_num)]], rho, tlist)
    return snot1* result.states[-1]

We start from the $|10>$ state and should get $|11>$ state if the operation is perfect

In [9]:
t_line = np.linspace(0.8*t,1.2*t,30)
correct_end_state = tensor(basis(2,1),basis(2,1))
F_line = list(map(lambda t: fidelity(noisy_CNOT(t), correct_end_state), t_line))
In [10]:
plt.plot(t_line/t, F_line)
plt.xlabel("$t'/t$")
plt.ylabel("Fidelity");

Comments

Post a Comment

Popular posts from this blog

Final submission of the project

This is the permanent link for the deliverables of the GSoC 2019 QuTiP project "Noise Models in QIP Module". The aim of this project is to equip the QuTiP `qip` module with a numerical simulator using the open system solver and the optimal control module. The final deliverables generalize this goal a little bit and establish a framework for NISQ (Noisy Intermediate-Scale Quantum) simulator, upon which models for different quantum devices can be built. Two existing examples in the `qip` modules were refactored and adapted to this new framework. We expect to release this new feature in the next major version of QuTiP. As it is a framework for simulation of quantum devices, future work includes implementing more concrete and modern examples of quantum computing models such us ion trap or superconducting quantum computing. The main deliverables containing the following: A numerical NISQ simulator using the QuTiP opens system solver. Refactoring the existing `SpinChain` a
Read more

Summary GSoC 2019

As we are approaching the end of this GSoC project, it is time to write a summary of the whole GSoC project. During the last two and a half months, the project basically followed the main points in the proposal and adapted the implementation details to the real situation. The final delivery of this project is a NISQ (Noisy Intermediate-Scale Quantum) simulator based on the QuTiP open system solver. It offers a framework for simulating quantum device. Three examples, the SpinChain, CavityQED and OptPulseProcessor demonstrate how to implement a concrete model. In addition,  we add a noise module as a framework for simulating device-dependent noise in the system. The main pull request is at  https://github.com/qutip/qutip/pull/1065 . This GSoC project has been the main theme of my past few months.  Before this project, my programming experience is only on home-work level and only for self-use. This is the first time that I work on a project that is going to be released and used by the o
Read more

Documentation and notebook examples

This week was dedicated to polishing the code, writing documentation and notebooks. I collected the notebook examples I wrote in the past two months and join them into three new notebooks in  https://github.com/qutip/qutip-notebooks/pull/88 . There is one notebook for NISQ simulation, one for OptPulseProcessor and one for the Deutsch-Jozsa Algorithm. The documentation is displayed blow. Since rendering is a little bit different, the GitHub version might be easier to read( https://github.com/BoxiLi/qutip-doc/blob/qip_doc/guide/guide-qip.rst ) Quantum Information Processing .. ipython:: :suppress: In [1]: from qutip import * In [1]: import numpy as np Introduction The Quantum Information Processing (QIP) module aims at providing basic tools for quantum computing simulation both for simple quantum algorithm design and for experiment realization. It offers two different approaches, one with :class:`qutip.qip.QubitCircuit` calculating unitary evolution u
Read more