Demo for user defined gates

User defined gate
In [1]:
from qutip import *
import numpy as np

User defined gates

This demo is based on the branch https://github.com/BoxiLi/qutip/tree/user_gate

A user defined gate can be specified by a python function that takes at most one parameter and return a Qobj, the dimension of the Qobj has to match the qubit system.

In [2]:
def user_gate1(arg_values):
    # controlled rotation X
    mat = np.zeros((4, 4), dtype=np.complex)
    mat[0, 0] = mat[1, 1] = 1.
    mat[2:4, 2:4] = rx(arg_values)
    return Qobj(mat, dims=[[2, 2], [2, 2]])

def user_gate2():
    # T gate
    mat = np.array([[1.,   0],
                    [0., 1.j]])
    return Qobj(mat, dims=[[2], [2]])

To let the QubitCircuit process those gates, one can modify its the attributes QubitCircuit.user_gates, which is a python dictionary in the form {name: gate_function}.

In [3]:
qc = QubitCircuit(2)
qc.user_gates = {"CTRLRX": user_gate1, 
                 "T"     : user_gate2}

When calling the add_gate method, the targets qubits and the argument need to be given.

In [4]:
# qubit 0 controlls qubit 1
qc.add_gate("CTRLRX", targets=[0,1], arg_value=np.pi/2)
# qubit 1 controlls qutbi 0
qc.add_gate("CTRLRX", targets=[1,0], arg_value=np.pi/2)
qc.add_gate("T", targets=[1])
props = qc.propagators()
In [5]:
props[0] # qubit 0 controlls qubit 1
Out[5]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.0\\0.0 & 1.0 & 0.0 & 0.0\\0.0 & 0.0 & 0.707 & -0.707j\\0.0 & 0.0 & -0.707j & 0.707\\\end{array}\right)\end{equation*}
In [6]:
props[1] # qubit 1 controlls qutbi 0
Out[6]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.0\\0.0 & 0.707 & 0.0 & -0.707j\\0.0 & 0.0 & 1.0 & 0.0\\0.0 & -0.707j & 0.0 & 0.707\\\end{array}\right)\end{equation*}
In [7]:
props[2] # T gate acts on qubit 1
Out[7]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.0\\0.0 & 1.0j & 0.0 & 0.0\\0.0 & 0.0 & 1.0 & 0.0\\0.0 & 0.0 & 0.0 & 1.0j\\\end{array}\right)\end{equation*}

molmer sorensen gate and qubit rotation gate

In [8]:
molmer_sorensen(np.pi/2, targets=[0, 1])
Out[8]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}0.707 & 0.0 & 0.0 & -0.707j\\0.0 & 0.707 & -0.707j & 0.0\\0.0 & -0.707j & 0.707 & 0.0\\-0.707j & 0.0 & 0.0 & 0.707\\\end{array}\right)\end{equation*}
In [9]:
molmer_sorensen(np.pi/2, N=3, targets=[1,2])
Out[9]:
Quantum object: dims = [[2, 2, 2], [2, 2, 2]], shape = (8, 8), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}0.707 & 0.0 & 0.0 & -0.707j & 0.0 & 0.0 & 0.0 & 0.0\\0.0 & 0.707 & -0.707j & 0.0 & 0.0 & 0.0 & 0.0 & 0.0\\0.0 & -0.707j & 0.707 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0\\-0.707j & 0.0 & 0.0 & 0.707 & 0.0 & 0.0 & 0.0 & 0.0\\0.0 & 0.0 & 0.0 & 0.0 & 0.707 & 0.0 & 0.0 & -0.707j\\0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.707 & -0.707j & 0.0\\0.0 & 0.0 & 0.0 & 0.0 & 0.0 & -0.707j & 0.707 & 0.0\\0.0 & 0.0 & 0.0 & 0.0 & -0.707j & 0.0 & 0.0 & 0.707\\\end{array}\right)\end{equation*}
In [10]:
qrot(np.pi/2,0)
Out[10]:
Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}0.707 & -0.707j\\-0.707j & 0.707\\\end{array}\right)\end{equation*}
In [11]:
qrot(np.pi/2,np.pi/2, N=2, target = 0)
Out[11]:
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = False\begin{equation*}\left(\begin{array}{*{11}c}0.707 & 0.0 & -0.707 & 0.0\\0.0 & 0.707 & 0.0 & -0.707\\0.707 & 0.0 & 0.707 & 0.0\\0.0 & 0.707 & 0.0 & 0.707\\\end{array}\right)\end{equation*}
In [ ]:

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

Solving technical problems in using QuTiP solver for CircuitProcessor

Image
Now we have the main ingredients for this project: CircuitProcessor as the simulator and CircuitNoise representing noise, it's time to go back and fix some technical issues. There were two unsolved problems discussed in the posts before: QuTiP solver interprets the array-like coefficients as smooth function and uses a cubic spline interpolation by default. However, as mentioned in  the previous blog , in CircuitProcessor we use the coefficients as a step function, i.e. coeff = [1,2,3] means that the pulse amplitude is 1 during t=[0,1), 2 during t=[1,2) and so on. This causes a mismatch in the result and was only solved temporarily by using Python function as coefficients. The solver requires that all the coefficients have the same tlist , which makes it difficult to add noise to the processor since the noise might have a different frequency. This was mentioned at the end of the last post . To solve the first problem we need to modify the solvers. Fortunately, the recent up...
Read more