Classes¶
Qobj¶

class
Qobj
(inpt=None, dims=[[], []], shape=[], type=None, isherm=None, copy=True, fast=False, superrep=None)[source]¶ A class for representing quantum objects, such as quantum operators and states.
The Qobj class is the QuTiP representation of quantum operators and state vectors. This class also implements math operations +,,* between Qobj instances (and / by a Cnumber), as well as a collection of common operator/state operations. The Qobj constructor optionally takes a dimension
list
and/or shapelist
as arguments.Parameters: inpt : array_like
Data for vector/matrix representation of the quantum object.
dims : list
Dimensions of object used for tensor products.
shape : list
Shape of underlying data structure (matrix shape).
copy : bool
Flag specifying whether Qobj should get a copy of the input data, or use the original.
fast : bool
Flag for fast qobj creation when running ode solvers. This parameter is used internally only.
Attributes
data (array_like) Sparse matrix characterizing the quantum object. dims (list) List of dimensions keeping track of the tensor structure. shape (list) Shape of the underlying data array. type (str) Type of quantum object: ‘bra’, ‘ket’, ‘oper’, ‘operatorket’, ‘operatorbra’, or ‘super’. superrep (str) Representation used if type is ‘super’. One of ‘super’ (Liouville form) or ‘choi’ (Choi matrix with tr = dimension). isherm (bool) Indicates if quantum object represents Hermitian operator. iscp (bool) Indicates if the quantum object represents a map, and if that map is completely positive (CP). ishp (bool) Indicates if the quantum object represents a map, and if that map is hermicity preserving (HP). istp (bool) Indicates if the quantum object represents a map, and if that map is trace preserving (TP). iscptp (bool) Indicates if the quantum object represents a map that is completely positive and trace preserving (CPTP). isket (bool) Indicates if the quantum object represents a ket. isbra (bool) Indicates if the quantum object represents a bra. isoper (bool) Indicates if the quantum object represents an operator. issuper (bool) Indicates if the quantum object represents a superoperator. isoperket (bool) Indicates if the quantum object represents an operator in column vector form. isoperbra (bool) Indicates if the quantum object represents an operator in row vector form. Methods
copy() Create copy of Qobj conj() Conjugate of quantum object. cosm() Cosine of quantum object. dag() Adjoint (dagger) of quantum object. dnorm() Diamond norm of quantum operator. dual_chan() Dual channel of quantum object representing a CP map. eigenenergies(sparse=False, sort=’low’, eigvals=0, tol=0, maxiter=100000) Returns eigenenergies (eigenvalues) of a quantum object. eigenstates(sparse=False, sort=’low’, eigvals=0, tol=0, maxiter=100000) Returns eigenenergies and eigenstates of quantum object. expm() Matrix exponential of quantum object. full() Returns dense array of quantum object data attribute. groundstate(sparse=False, tol=0, maxiter=100000) Returns eigenvalue and eigenket for the groundstate of a quantum object. matrix_element(bra, ket) Returns the matrix element of operator between bra and ket vectors. norm(norm=’tr’, sparse=False, tol=0, maxiter=100000) Returns norm of a ket or an operator. permute(order) Returns composite qobj with indices reordered. ptrace(sel) Returns quantum object for selected dimensions after performing partial trace. sinm() Sine of quantum object. sqrtm() Matrix square root of quantum object. tidyup(atol=1e12) Removes small elements from quantum object. tr() Trace of quantum object. trans() Transpose of quantum object. transform(inpt, inverse=False) Performs a basis transformation defined by inpt matrix. trunc_neg(method=’clip’) Removes negative eigenvalues and returns a new Qobj that is a valid density operator. unit(norm=’tr’, sparse=False, tol=0, maxiter=100000) Returns normalized quantum object. 
check_herm
()[source]¶ Check if the quantum object is hermitian.
Returns: isherm : bool
Returns the new value of isherm property.

cosm
()[source]¶ Cosine of a quantum operator.
Operator must be square.
Returns: oper : qobj
Matrix cosine of operator.
Raises: TypeError
Quantum object is not square.
Notes
Uses the Q.expm() method.

diag
()[source]¶ Diagonal elements of quantum object.
Returns: diags : array
Returns array of
real
values if operators is Hermitian, otherwisecomplex
values are returned.

dnorm
(B=None)[source]¶ Calculates the diamond norm, or the diamond distance to another operator.
Parameters: B : Qobj or None
If B is not None, the diamond distance d(A, B) = dnorm(A  B) between this operator and B is returned instead of the diamond norm.
Returns: d : float
Either the diamond norm of this operator, or the diamond distance from this operator to B.

eigenenergies
(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)[source]¶ Eigenenergies of a quantum object.
Eigenenergies (eigenvalues) are defined for operators or superoperators only.
Parameters: sparse : bool
Use sparse Eigensolver
sort : str
Sort eigenvalues ‘low’ to high, or ‘high’ to low.
eigvals : int
Number of requested eigenvalues. Default is all eigenvalues.
tol : float
Tolerance used by sparse Eigensolver (0=machine precision). The sparse solver may not converge if the tolerance is set too low.
maxiter : int
Maximum number of iterations performed by sparse solver (if used).
Returns: eigvals : array
Array of eigenvalues for operator.
Notes
The sparse eigensolver is much slower than the dense version. Use sparse only if memory requirements demand it.

eigenstates
(sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000)[source]¶ Eigenstates and eigenenergies.
Eigenstates and eigenenergies are defined for operators and superoperators only.
Parameters: sparse : bool
Use sparse Eigensolver
sort : str
Sort eigenvalues (and vectors) ‘low’ to high, or ‘high’ to low.
eigvals : int
Number of requested eigenvalues. Default is all eigenvalues.
tol : float
Tolerance used by sparse Eigensolver (0 = machine precision). The sparse solver may not converge if the tolerance is set too low.
maxiter : int
Maximum number of iterations performed by sparse solver (if used).
Returns: eigvals : array
Array of eigenvalues for operator.
eigvecs : array
Array of quantum operators representing the oprator eigenkets. Order of eigenkets is determined by order of eigenvalues.
Notes
The sparse eigensolver is much slower than the dense version. Use sparse only if memory requirements demand it.

eliminate_states
(states_inds, normalize=False)[source]¶ Creates a new quantum object with states in state_inds eliminated.
Parameters: states_inds : list of integer
The states that should be removed.
normalize : True / False
Weather or not the new Qobj instance should be normalized (default is False). For Qobjs that represents density matrices or state vectors normalized should probably be set to True, but for Qobjs that represents operators in for example an Hamiltonian, normalize should be False.
Returns: q : Qobj
A new instance of
qutip.Qobj
that contains only the states corresponding to indices that are not in state_inds.Notes
Experimental.

static
evaluate
(qobj_list, t, args)[source]¶ Evaluate a timedependent quantum object in list format. For example,
qobj_list = [H0, [H1, func_t]]is evaluated to
Qobj(t) = H0 + H1 * func_t(t, args)and
qobj_list = [H0, [H1, ‘sin(w * t)’]]is evaluated to
Qobj(t) = H0 + H1 * sin(args[‘w’] * t)Parameters: qobj_list : list
A nested list of Qobj instances and corresponding timedependent coefficients.
t : float
The time for which to evaluate the timedependent Qobj instance.
args : dictionary
A dictionary with parameter values required to evaluate the timedependent Qobj intance.
Returns: output : Qobj
A Qobj instance that represents the value of qobj_list at time t.

expm
(method='dense')[source]¶ Matrix exponential of quantum operator.
Input operator must be square.
Parameters: method : str {‘dense’, ‘sparse’}
Use set method to use to calculate the matrix exponentiation. The available choices includes ‘dense’ and ‘sparse’. Since the exponential of a matrix is nearly always dense, method=’dense’ is set as default.s
Returns: oper : qobj
Exponentiated quantum operator.
Raises: TypeError
Quantum operator is not square.

extract_states
(states_inds, normalize=False)[source]¶ Qobj with states in state_inds only.
Parameters: states_inds : list of integer
The states that should be kept.
normalize : True / False
Weather or not the new Qobj instance should be normalized (default is False). For Qobjs that represents density matrices or state vectors normalized should probably be set to True, but for Qobjs that represents operators in for example an Hamiltonian, normalize should be False.
Returns: q : Qobj
A new instance of
qutip.Qobj
that contains only the states corresponding to the indices in state_inds.Notes
Experimental.

full
(squeeze=False)[source]¶ Dense array from quantum object.
Returns: data : array
Array of complex data from quantum objects data attribute.

groundstate
(sparse=False, tol=0, maxiter=100000, safe=True)[source]¶ Ground state Eigenvalue and Eigenvector.
Defined for quantum operators or superoperators only.
Parameters: sparse : bool
Use sparse Eigensolver
tol : float
Tolerance used by sparse Eigensolver (0 = machine precision). The sparse solver may not converge if the tolerance is set too low.
maxiter : int
Maximum number of iterations performed by sparse solver (if used).
safe : bool (default=True)
Check for degenerate ground state
Returns: eigval : float
Eigenvalue for the ground state of quantum operator.
eigvec : qobj
Eigenket for the ground state of quantum operator.
Notes
The sparse eigensolver is much slower than the dense version. Use sparse only if memory requirements demand it.

matrix_element
(bra, ket)[source]¶ Calculates a matrix element.
Gives the matrix element for the quantum object sandwiched between a bra and ket vector.
Parameters: bra : qobj
Quantum object of type ‘bra’.
ket : qobj
Quantum object of type ‘ket’.
Returns: elem : complex
Complex valued matrix element.
Raises: TypeError
Can only calculate matrix elements between a bra and ket quantum object.

norm
(norm=None, sparse=False, tol=0, maxiter=100000)[source]¶ Norm of a quantum object.
Default norm is L2norm for kets and tracenorm for operators. Other ket and operator norms may be specified using the norm and argument.
Parameters: norm : str
Which norm to use for ket/bra vectors: L2 ‘l2’, max norm ‘max’, or for operators: trace ‘tr’, Frobius ‘fro’, one ‘one’, or max ‘max’.
sparse : bool
Use sparse eigenvalue solver for trace norm. Other norms are not affected by this parameter.
tol : float
Tolerance for sparse solver (if used) for trace norm. The sparse solver may not converge if the tolerance is set too low.
maxiter : int
Maximum number of iterations performed by sparse solver (if used) for trace norm.
Returns: norm : float
The requested norm of the operator or state quantum object.
Notes
The sparse eigensolver is much slower than the dense version. Use sparse only if memory requirements demand it.

overlap
(state)[source]¶ Overlap between two state vectors.
Gives the overlap (scalar product) for the quantum object and state state vector.
Parameters: state : qobj
Quantum object for a state vector of type ‘ket’ or ‘bra’.
Returns: overlap : complex
Complex valued overlap.
Raises: TypeError
Can only calculate overlap between a bra and ket quantum objects.

permute
(order)[source]¶ Permutes a composite quantum object.
Parameters: order : list/array
List specifying new tensor order.
Returns: P : qobj
Permuted quantum object.

ptrace
(sel)[source]¶ Partial trace of the quantum object.
Parameters: sel : int/list
An
int
orlist
of components to keep after partial trace.Returns: oper : qobj
Quantum object representing partial trace with selected components remaining.
Notes
This function is identical to the
qutip.qobj.ptrace
function that has been deprecated.

sinm
()[source]¶ Sine of a quantum operator.
Operator must be square.
Returns: oper : qobj
Matrix sine of operator.
Raises: TypeError
Quantum object is not square.
Notes
Uses the Q.expm() method.

sqrtm
(sparse=False, tol=0, maxiter=100000)[source]¶ Sqrt of a quantum operator.
Operator must be square.
Parameters: sparse : bool
Use sparse eigenvalue/vector solver.
tol : float
Tolerance used by sparse solver (0 = machine precision).
maxiter : int
Maximum number of iterations used by sparse solver.
Returns: oper : qobj
Matrix square root of operator.
Raises: TypeError
Quantum object is not square.
Notes
The sparse eigensolver is much slower than the dense version. Use sparse only if memory requirements demand it.

tidyup
(atol=None)[source]¶ Removes small elements from the quantum object.
Parameters: atol : float
Absolute tolerance used by tidyup. Default is set via qutip global settings parameters.
Returns: oper : qobj
Quantum object with small elements removed.

tr
()[source]¶ Trace of a quantum object.
Returns: trace : float
Returns
real
if operator is Hermitian, returnscomplex
otherwise.

transform
(inpt, inverse=False, sparse=True)[source]¶ Basis transform defined by input array.
Input array can be a
matrix
defining the transformation, or alist
of kets that defines the new basis.Parameters: inpt : array_like
A
matrix
orlist
of kets defining the transformation.inverse : bool
Whether to return inverse transformation.
sparse : bool
Use sparse matrices when possible. Can be slower.
Returns: oper : qobj
Operator in new basis.
Notes
This function is still in development.

trunc_neg
(method='clip')[source]¶ Truncates negative eigenvalues and renormalizes.
Returns a new Qobj by removing the negative eigenvalues of this instance, then renormalizing to obtain a valid density operator.
Parameters: method : str
Algorithm to use to remove negative eigenvalues. “clip” simply discards negative eigenvalues, then renormalizes. “sgs” uses the SGS algorithm (doi:10/bb76) to find the positive operator that is nearest in the Shatten 2norm.
Returns: oper : qobj
A valid density operator.

unit
(norm=None, sparse=False, tol=0, maxiter=100000)[source]¶ Operator or state normalized to unity.
Uses norm from Qobj.norm().
Parameters: norm : str
Requested norm for states / operators.
sparse : bool
Use sparse eigensolver for trace norm. Does not affect other norms.
tol : float
Tolerance used by sparse eigensolver.
maxiter : int
Number of maximum iterations performed by sparse eigensolver.
Returns: oper : qobj
Normalized quantum object.

eseries¶

class
eseries
(q=array([], dtype=object), s=array([], dtype=float64))[source]¶ Class representation of an exponentialseries expansion of timedependent quantum objects.
Attributes
ampl (ndarray) Array of amplitudes for exponential series. rates (ndarray) Array of rates for exponential series. dims (list) Dimensions of exponential series components shape (list) Shape corresponding to exponential series components Methods
value(tlist) Evaluate an exponential series at the times listed in tlist spec(wlist) Evaluate the spectrum of an exponential series at frequencies in wlist. tidyup() Returns a tidier version of the exponential series
Bloch sphere¶

class
Bloch
(fig=None, axes=None, view=None, figsize=None, background=False)[source]¶ Class for plotting data on the Bloch sphere. Valid data can be either points, vectors, or qobj objects.
Attributes
axes (instance {None}) User supplied Matplotlib axes for Bloch sphere animation. fig (instance {None}) User supplied Matplotlib Figure instance for plotting Bloch sphere. font_color (str {‘black’}) Color of font used for Bloch sphere labels. font_size (int {20}) Size of font used for Bloch sphere labels. frame_alpha (float {0.1}) Sets transparency of Bloch sphere frame. frame_color (str {‘gray’}) Color of sphere wireframe. frame_width (int {1}) Width of wireframe. point_color (list {[“b”,”r”,”g”,”#CC6600”]}) List of colors for Bloch sphere point markers to cycle through. i.e. By default, points 0 and 4 will both be blue (‘b’). point_marker (list {[“o”,”s”,”d”,”^”]}) List of point marker shapes to cycle through. point_size (list {[25,32,35,45]}) List of point marker sizes. Note, not all point markers look the same size when plotted! sphere_alpha (float {0.2}) Transparency of Bloch sphere itself. sphere_color (str {‘#FFDDDD’}) Color of Bloch sphere. figsize (list {[7,7]}) Figure size of Bloch sphere plot. Best to have both numbers the same; otherwise you will have a Bloch sphere that looks like a football. vector_color (list {[“g”,”#CC6600”,”b”,”r”]}) List of vector colors to cycle through. vector_width (int {5}) Width of displayed vectors. vector_style (str {‘>’, ‘simple’, ‘fancy’, ‘’}) Vector arrowhead style (from matplotlib’s arrow style). vector_mutation (int {20}) Width of vectors arrowhead. view (list {[60,30]}) Azimuthal and Elevation viewing angles. xlabel (list {[“$x$”,”“]}) List of strings corresponding to +x and x axes labels, respectively. xlpos (list {[1.1,1.1]}) Positions of +x and x labels respectively. ylabel (list {[“$y$”,”“]}) List of strings corresponding to +y and y axes labels, respectively. ylpos (list {[1.2,1.2]}) Positions of +y and y labels respectively. zlabel (list {[r’$left0right>$’,r’$left1right>$’]}) List of strings corresponding to +z and z axes labels, respectively. zlpos (list {[1.2,1.2]}) Positions of +z and z labels respectively. 
add_annotation
(state_or_vector, text, **kwargs)[source]¶ Add a text or LaTeX annotation to Bloch sphere, parametrized by a qubit state or a vector.
Parameters: state_or_vector : Qobj/array/list/tuple
Position for the annotaion. Qobj of a qubit or a vector of 3 elements.
text : str/unicode
Annotation text. You can use LaTeX, but remember to use raw string e.g. r”$langle x rangle$” or escape backslashes e.g. “$\langle x \rangle$”.
**kwargs :
Options as for mplot3d.axes3d.text, including: fontsize, color, horizontalalignment, verticalalignment.

add_points
(points, meth='s')[source]¶ Add a list of data points to bloch sphere.
Parameters: points : array/list
Collection of data points.
meth : str {‘s’, ‘m’, ‘l’}
Type of points to plot, use ‘m’ for multicolored, ‘l’ for points connected with a line.

add_states
(state, kind='vector')[source]¶ Add a state vector Qobj to Bloch sphere.
Parameters: state : qobj
Input state vector.
kind : str {‘vector’,’point’}
Type of object to plot.

add_vectors
(vectors)[source]¶ Add a list of vectors to Bloch sphere.
Parameters: vectors : array_like
Array with vectors of unit length or smaller.

render
(fig=None, axes=None)[source]¶ Render the Bloch sphere and its data sets in on given figure and axes.

save
(name=None, format='png', dirc=None)[source]¶ Saves Bloch sphere to file of type
format
in directorydirc
.Parameters: name : str
Name of saved image. Must include path and format as well. i.e. ‘/Users/Paul/Desktop/bloch.png’ This overrides the ‘format’ and ‘dirc’ arguments.
format : str
Format of output image.
dirc : str
Directory for output images. Defaults to current working directory.
Returns: File containing plot of Bloch sphere.

set_label_convention
(convention)[source]¶ Set x, y and z labels according to one of conventions.
Parameters: convention : string
One of the following:
 “original”
 “xyz”
 “sx sy sz”
 “01”
 “polarization jones”
 “polarization jones letters” see also: http://en.wikipedia.org/wiki/Jones_calculus
 “polarization stokes” see also: http://en.wikipedia.org/wiki/Stokes_parameters

vector_mutation
= None¶ Sets the width of the vectors arrowhead

vector_width
= None¶ Width of Bloch vectors, default = 5

Cubic Spline¶

class
Cubic_Spline
(a, b, y, alpha=0, beta=0)[source]¶ Calculates coefficients for a cubic spline interpolation of a given data set.
This function assumes that the data is sampled uniformly over a given interval.
Parameters: a : float
Lower bound of the interval.
b : float
Upper bound of the interval.
y : ndarray
Function values at interval points.
alpha : float
Secondorder derivative at a. Default is 0.
beta : float
Secondorder derivative at b. Default is 0.
Notes
This object can be called like a normal function with a single or array of input points at which to evaluate the interplating function.
Habermann & Kindermann, “Multidimensional Spline Interpolation: Theory and Applications”, Comput Econ 30, 153 (2007).
Attributes
a (float) Lower bound of the interval. b (float) Upper bound of the interval. coeffs (ndarray) Array of coeffcients defining cubic spline.
NonMarkovian Solvers¶

class
HEOMSolver
[source]¶ This is superclass for all solvers that use the HEOM method for calculating the dynamics evolution. There are many references for this. A good introduction, and perhaps closest to the notation used here is: DOI:10.1103/PhysRevLett.104.250401 A more canonical reference, with full derivation is: DOI: 10.1103/PhysRevA.41.6676 The method can compute open system dynamics without using any Markovian or rotating wave approximation (RWA) for systems where the bath correlations can be approximated to a sum of complex eponentials. The method builds a matrix of linked differential equations, which are then solved used the same ODE solvers as other qutip solvers (e.g. mesolve)
This class should be treated as abstract. Currently the only subclass implemented is that for the DrudeLorentz spectral density. This covers the majority of the work that has been done using this model, and there are some performance advantages to assuming this model where it is appropriate.
There are opportunities to develop a more general spectral density code.
Attributes
H_sys (Qobj) System Hamiltonian coup_op (Qobj) Operator describing the coupling between system and bath. coup_strength (float) Coupling strength. temperature (float) Bath temperature, in units corresponding to planck N_cut (int) Cutoff parameter for the bath N_exp (int) Number of exponential terms used to approximate the bath correlation functions planck (float) reduced Planck constant boltzmann (float) Boltzmann’s constant options ( qutip.solver.Options
) Generic solver options. If set to None the default options will be usedprogress_bar: BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation. stats ( qutip.solver.Stats
) optional container for holding performance statitics If None is set, then statistics are not collected There may be an overhead in collecting statisticsexp_coeff (list of complex) Coefficients for the exponential series terms exp_freq (list of complex) Frequencies for the exponential series terms 
configure
(H_sys, coup_op, coup_strength, temperature, N_cut, N_exp, planck=None, boltzmann=None, renorm=None, bnd_cut_approx=None, options=None, progress_bar=None, stats=None)[source]¶ Configure the solver using the passed parameters The parameters are described in the class attributes, unless there is some specific behaviour
Parameters: options :
qutip.solver.Options
Generic solver options. If set to None the default options will be used
progress_bar: BaseProgressBar
Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation. If set to None, then the default progress bar will be used Set to False for no progress bar
stats: :class:`qutip.solver.Stats`
Optional instance of solver.Stats, or a subclass thereof, for storing performance statistics for the solver If set to True, then the default Stats for this class will be used Set to False for no stats


class
HSolverDL
(H_sys, coup_op, coup_strength, temperature, N_cut, N_exp, cut_freq, planck=1.0, boltzmann=1.0, renorm=True, bnd_cut_approx=True, options=None, progress_bar=None, stats=None)[source]¶ HEOM solver based on the DrudeLorentz model for spectral density. DrudeLorentz bath the correlation functions can be exactly analytically expressed as an infinite sum of exponentials which depend on the temperature, these are called the Matsubara terms or Matsubara frequencies
For practical computation purposes an approximation must be used based on a small number of Matsubara terms (typically < 4).
Attributes
cut_freq (float) Bath spectral density cutoff frequency. renorm (bool) Apply renormalisation to coupling terms Can be useful if using SI units for planck and boltzmann bnd_cut_approx (bool) Use boundary cut off approximation Can be 
configure
(H_sys, coup_op, coup_strength, temperature, N_cut, N_exp, cut_freq, planck=None, boltzmann=None, renorm=None, bnd_cut_approx=None, options=None, progress_bar=None, stats=None)[source]¶ Calls configure from
HEOMSolver
and sets any attributes that are specific to this subclass

run
(rho0, tlist)[source]¶ Function to solve for an open quantum system using the HEOM model.
Parameters: rho0 : Qobj
Initial state (density matrix) of the system.
tlist : list
Time over which system evolves.
Returns: results :
qutip.solver.Result
Object storing all results from the simulation.


class
MemoryCascade
(H_S, L1, L2, S_matrix=None, c_ops_markov=None, integrator='propagator', parallel=False, options=None)[source]¶ Class for running memory cascade simulations of open quantum systems with timedelayed coherent feedback.
Attributes
H_S ( qutip.Qobj
) System Hamiltonian (can also be a Liouvillian)L1 ( qutip.Qobj
/ list ofqutip.Qobj
) System operators coupling into the feedback loop. Can be a single operator or a list of operators.L2 ( qutip.Qobj
/ list ofqutip.Qobj
) System operators coupling out of the feedback loop. Can be a single operator or a list of operators. L2 must have the same length as L1.S_matrix: array S matrix describing which operators in L1 are coupled to which operators in L2 by the feedback channel. Defaults to an n by n identity matrix where n is the number of elements in L1/L2. c_ops_markov ( qutip.Qobj
/ list ofqutip.Qobj
) Decay operators describing conventional Markovian decay channels. Can be a single operator or a list of operators.integrator (str {‘propagator’, ‘mesolve’}) Integrator method to use. Defaults to ‘propagator’ which tends to be faster for long times (i.e., large Hilbert space). parallel (bool) Run integrator in parallel if True. Only implemented for ‘propagator’ as the integrator method. options ( qutip.solver.Options
) Generic solver options.
outfieldcorr
(rho0, blist, tlist, tau, c1=None, c2=None)[source]¶ Compute output field expectation value <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and O_i = I, b_out, b_out^dagger, b_loop, b_loop^dagger
Parameters: rho0 :
qutip.Qobj
initial density matrix or state vector (ket).
blist : array_like
List of integers specifying the field operators: 0: I (nothing) 1: b_out 2: b_out^dagger 3: b_loop 4: b_loop^dagger
tlist : array_like
list of corresponding times t1,..,tn at which to evaluate the field operators
tau : float
timedelay
c1 :
qutip.Qobj
system collapse operator that couples to the inloop field in question (only needs to be specified if self.L1 has more than one element)
c2 :
qutip.Qobj
system collapse operator that couples to the output field in question (only needs to be specified if self.L2 has more than one element)
Returns: : complex
expectation value of field correlation function

outfieldpropagator
(blist, tlist, tau, c1=None, c2=None, notrace=False)[source]¶ Compute propagator for computing output field expectation values <O_n(tn)...O_2(t2)O_1(t1)> for times t1,t2,... and O_i = I, b_out, b_out^dagger, b_loop, b_loop^dagger
Parameters: blist : array_like
List of integers specifying the field operators: 0: I (nothing) 1: b_out 2: b_out^dagger 3: b_loop 4: b_loop^dagger
tlist : array_like
list of corresponding times t1,..,tn at which to evaluate the field operators
tau : float
timedelay
c1 :
qutip.Qobj
system collapse operator that couples to the inloop field in question (only needs to be specified if self.L1 has more than one element)
c2 :
qutip.Qobj
system collapse operator that couples to the output field in question (only needs to be specified if self.L2 has more than one element)
notrace : bool {False}
If this optional is set to True, a propagator is returned for a cascade of k systems, where \((k1) tau < t < k tau\). If set to False (default), a generalized partial trace is performed and a propagator for a single system is returned.
Returns: timepropagator for computing field correlation function

propagator
(t, tau, notrace=False)[source]¶ Compute propagator for time t and timedelay tau
Parameters: t : float
current time
tau : float
timedelay
notrace : bool {False}
If this optional is set to True, a propagator is returned for a cascade of k systems, where \((k1) tau < t < k tau\). If set to False (default), a generalized partial trace is performed and a propagator for a single system is returned.
Returns
——
: :class:`qutip.Qobj`
timepropagator for reduced system dynamics

rhot
(rho0, t, tau)[source]¶ Compute the reduced system density matrix \(\rho(t)\)
Parameters: rho0 :
qutip.Qobj
initial density matrix or state vector (ket)
t : float
current time
tau : float
timedelay
Returns: density matrix at time \(t\)


class
TTMSolverOptions
(dynmaps=None, times=[], learningtimes=[], thres=0.0, options=None)[source]¶ Class of options for the Transfer Tensor Method solver.
Attributes
dynmaps (list of qutip.Qobj
) List of precomputed dynamical maps (superoperators), or a callback function that returns the superoperator at a given time.times (array_like) List of times \(t_n\) at which to calculate \(\rho(t_n)\) learningtimes (array_like) List of times \(t_k\) to use as learning times if argument dynmaps is a callback function. thres (float) Threshold for halting. Halts if \(T_{n}T_{n1}\) is below treshold. options ( qutip.solver.Options
) Generic solver options.
Solver Options and Results¶

class
Options
(atol=1e08, rtol=1e06, method='adams', order=12, nsteps=1000, first_step=0, max_step=0, min_step=0, average_expect=True, average_states=False, tidy=True, num_cpus=0, norm_tol=0.001, norm_steps=5, rhs_reuse=False, rhs_filename=None, ntraj=500, gui=False, rhs_with_state=False, store_final_state=False, store_states=False, seeds=None, steady_state_average=False, normalize_output=True, use_openmp=None, openmp_threads=None)[source]¶ Class of options for evolution solvers such as
qutip.mesolve
andqutip.mcsolve
. Options can be specified either as arguments to the constructor:opts = Options(order=10, ...)
or by changing the class attributes after creation:
opts = Options() opts.order = 10
Returns options class to be used as options in evolution solvers.
Attributes
atol (float {1e8}) Absolute tolerance. rtol (float {1e6}) Relative tolerance. method (str {‘adams’,’bdf’}) Integration method. order (int {12}) Order of integrator (<=12 ‘adams’, <=5 ‘bdf’) nsteps (int {2500}) Max. number of internal steps/call. first_step (float {0}) Size of initial step (0 = automatic). min_step (float {0}) Minimum step size (0 = automatic). max_step (float {0}) Maximum step size (0 = automatic) tidy (bool {True,False}) Tidyup Hamiltonian and initial state by removing small terms. num_cpus (int) Number of cpus used by mcsolver (default = # of cpus). norm_tol (float) Tolerance used when finding wavefunction norm in mcsolve. norm_steps (int) Max. number of steps used to find wavefunction norm to within norm_tol in mcsolve. average_states (bool {False}) Average states values over trajectories in stochastic solvers. average_expect (bool {True}) Average expectation values over trajectories for stochastic solvers. mc_corr_eps (float {1e10}) Arbitrarily small value for eliminating any dividebyzero errors in correlation calculations when using mcsolve. ntraj (int {500}) Number of trajectories in stochastic solvers. openmp_threads (int) Number of OPENMP threads to use. Default is number of cpu cores. rhs_reuse (bool {False,True}) Reuse Hamiltonian data. rhs_with_state (bool {False,True}) Whether or not to include the state in the Hamiltonian function callback signature. rhs_filename (str) Name for compiled Cython file. seeds (ndarray) Array containing random number seeds for mcsolver. store_final_state (bool {False, True}) Whether or not to store the final state of the evolution in the result class. store_states (bool {False, True}) Whether or not to store the state vectors or density matrices in the result class, even if expectation values operators are given. If no expectation are provided, then states are stored by default and this option has no effect. use_openmp (bool {True, False}) Use OPENMP for sparse matrix vector multiplication. Default None means auto check.

class
Result
[source]¶ Class for storing simulation results from any of the dynamics solvers.
Attributes
solver (str) Which solver was used [e.g., ‘mesolve’, ‘mcsolve’, ‘brmesolve’, ...] times (list/array) Times at which simulation data was collected. expect (list/array) Expectation values (if requested) for simulation. states (array) State of the simulation (density matrix or ket) evaluated at times
.num_expect (int) Number of expectation value operators in simulation. num_collapse (int) Number of collapse operators in simualation. ntraj (int/list) Number of trajectories (for stochastic solvers). A list indicates that averaging of expectation values was done over a subset of total number of trajectories. col_times (list) Times at which state collpase occurred. Only for Monte Carlo solver. col_which (list) Which collapse operator was responsible for each collapse in col_times
. Only for Monte Carlo solver.

class
Stats
(section_names=None)[source]¶ Statistical information on the solver performance Statistics can be grouped into sections. If no section names are given in the the contructor, then all statistics will be added to one section ‘main’
Parameters: section_names : list
list of keys that will be used as keys for the sections These keys will also be used as names for the sections The text in the output can be overidden by setting the header property of the section If no names are given then one section called ‘main’ is created
Attributes
sections (OrderedDict of _StatsSection) These are the sections that are created automatically on instantiation or added using add_section header (string) Some text that will be used as the heading in the report By default there is None total_time (float) Time in seconds for the solver to complete processing Can be None, meaning that total timing percentages will be reported Methods
add_section
add_count
add_timing
add_message
report: Output the statistics report to console or file. 
add_count
(key, value, section=None)[source]¶ Add value to count. If key does not already exist in section then it is created with this value. If key already exists it is increased by the give value value is expected to be an integer
Parameters: key : string
key for the section.counts dictionary reusing a key will result in numerical addition of value
value : int
Initial value of the count, or added to an existing count
section: string or `class` : _StatsSection
Section which to add the count to. If None given, the default (first) section will be used

add_message
(key, value, section=None, sep=';')[source]¶ Add value to message. If key does not already exist in section then it is created with this value. If key already exists the value is added to the message The value will be converted to a string
Parameters: key : string
key for the section.messages dictionary reusing a key will result in concatenation of value
value : int
Initial value of the message, or added to an existing message
sep : string
Message will be prefixed with this string when concatenating
section: string or `class` : _StatsSection
Section which to add the message to. If None given, the default (first) section will be used

add_section
(name)[source]¶ Add another section with the given name
Parameters: name : string
will be used as key for sections dict will also be the header for the section
Returns: section : class
The new section

add_timing
(key, value, section=None)[source]¶ Add value to timing. If key does not already exist in section then it is created with this value. If key already exists it is increased by the give value value is expected to be a float, and given in seconds.
Parameters: key : string
key for the section.timings dictionary reusing a key will result in numerical addition of value
value : int
Initial value of the timing, or added to an existing timing
section: string or `class` : _StatsSection
Section which to add the timing to. If None given, the default (first) section will be used

report
(output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF8'>)[source]¶ Report the counts, timings and messages from the sections. Sections are reported in the order that the names were supplied in the constructor. The counts, timings and messages are reported in the order that they are added to the sections The output can be written to anything that supports a write method, e.g. a file or the console (default) The output is intended to in markdown format
Parameters: output : stream
file or console stream  anything that support write  where the output will be written

set_total_time
(value, section=None)[source]¶ Sets the total time for the complete solve or for a specific section value is expected to be a float, and given in seconds
Parameters: value : float
Time in seconds to complete the solver section
section : string or class
Section which to set the total_time for If None given, the total_time for complete solve is set


class
StochasticSolverOptions
(H=None, state0=None, times=None, c_ops=[], sc_ops=[], e_ops=[], m_ops=None, args=None, ntraj=1, nsubsteps=1, d1=None, d2=None, d2_len=1, dW_factors=None, rhs=None, generate_A_ops=None, generate_noise=None, homogeneous=True, solver=None, method=None, distribution='normal', store_measurement=False, noise=None, normalize=True, options=None, progress_bar=None, map_func=None, map_kwargs=None)[source]¶ Class of options for stochastic solvers such as
qutip.stochastic.ssesolve
,qutip.stochastic.smesolve
, etc. Options can be specified either as arguments to the constructor:sso = StochasticSolverOptions(nsubsteps=100, ...)
or by changing the class attributes after creation:
sso = StochasticSolverOptions() sso.nsubsteps = 1000
The stochastic solvers
qutip.stochastic.ssesolve
,qutip.stochastic.smesolve
,qutip.stochastic.ssepdpsolve
andqutip.stochastic.smepdpsolve
all take the same keyword arguments as the constructor of these class, and internally they use these arguments to construct an instance of this class, so it is rarely needed to explicitly create an instance of this class.Attributes
H ( qutip.Qobj
) System Hamiltonian.state0 ( qutip.Qobj
) Initial state vector (ket) or density matrix.times (list / array) List of times for \(t\). Must be uniformly spaced. c_ops (list of qutip.Qobj
) List of deterministic collapse operators.sc_ops (list of qutip.Qobj
) List of stochastic collapse operators. Each stochastic collapse operator will give a deterministic and stochastic contribution to the equation of motion according to how the d1 and d2 functions are defined.e_ops (list of qutip.Qobj
) Single operator or list of operators for which to evaluate expectation values.m_ops (list of qutip.Qobj
) List of operators representing the measurement operators. The expected format is a nested list with one measurement operator for each stochastic increament, for each stochastic collapse operator.args (dict / list) List of dictionary of additional problemspecific parameters. Implicit methods can adjust tolerance via args = {‘tol’:value} ntraj (int) Number of trajectors. nsubsteps (int) Number of sub steps between each timespep given in times. d1 (function) Function for calculating the operatorvalued coefficient to the deterministic increment dt. d2 (function) Function for calculating the operatorvalued coefficient to the stochastic increment(s) dW_n, where n is in [0, d2_len[. d2_len (int (default 1)) The number of stochastic increments in the process. dW_factors (array) Array of length d2_len, containing scaling factors for each measurement operator in m_ops. rhs (function) Function for calculating the deterministic and stochastic contributions to the righthand side of the stochastic differential equation. This only needs to be specified when implementing a custom SDE solver. generate_A_ops (function) Function that generates a list of precomputed operators or super operators. These precomputed operators are used in some d1 and d2 functions. generate_noise (function) Function for generate an array of precomputed noise signal. homogeneous (bool (True)) Wheter or not the stochastic process is homogenous. Inhomogenous processes are only supported for poisson distributions. solver (string) Name of the solver method to use for solving the stochastic equations. Valid values are: 1/2 order algorithms: ‘eulermaruyama’, ‘fasteulermaruyama’, ‘pceuler’ is a predictorcorrector method which is more stable than explicit methods, 1 order algorithms: ‘milstein’, ‘fastmilstein’, ‘platen’, ‘milsteinimp’ is semiimplicit Milstein method, 3/2 order algorithms: ‘taylor15’, ‘taylor15imp’ is semiimplicit Taylor 1.5 method. Implicit methods can adjust tolerance via args = {‘tol’:value}, default is {‘tol’:1e6} method (string (‘homodyne’, ‘heterodyne’, ‘photocurrent’)) The name of the type of measurement process that give rise to the stochastic equation to solve. Specifying a method with this keyword argument is a shorthand notation for using predefined d1 and d2 functions for the corresponding stochastic processes. distribution (string (‘normal’, ‘poission’)) The name of the distribution used for the stochastic increments. store_measurements (bool (default False)) Whether or not to store the measurement results in the qutip.solver.SolverResult
instance returned by the solver.noise (array) Vector specifying the noise. normalize (bool (default True)) Whether or not to normalize the wave function during the evolution. options ( qutip.solver.Options
) Generic solver options.map_func: function A map function or managing the calls to singletrajactory solvers. map_kwargs: dictionary Optional keyword arguments to the map_func function function. progress_bar ( qutip.ui.BaseProgressBar
) Optional progress bar class instance.
Distribution functions¶

class
Distribution
(data=None, xvecs=[], xlabels=[])[source]¶ A class for representation spatial distribution functions.
The Distribution class can be used to prepresent spatial distribution functions of arbitray dimension (although only 1D and 2D distributions are used so far).
It is indented as a base class for specific distribution function, and provide implementation of basic functions that are shared among all Distribution functions, such as visualization, calculating marginal distributions, etc.
Parameters: data : array_like
Data for the distribution. The dimensions must match the lengths of the coordinate arrays in xvecs.
xvecs : list
List of arrays that spans the space for each coordinate.
xlabels : list
List of labels for each coordinate.

marginal
(dim=0)[source]¶ Calculate the marginal distribution function along the dimension dim. Return a new Distribution instance describing this reduced dimensionality distribution.
Parameters: dim : int
The dimension (coordinate index) along which to obtain the marginal distribution.
Returns: d : Distributions
A new instances of Distribution that describes the marginal distribution.

project
(dim=0)[source]¶ Calculate the projection (max value) distribution function along the dimension dim. Return a new Distribution instance describing this reduceddimensionality distribution.
Parameters: dim : int
The dimension (coordinate index) along which to obtain the projected distribution.
Returns: d : Distributions
A new instances of Distribution that describes the projection.

visualize
(fig=None, ax=None, figsize=(8, 6), colorbar=True, cmap=None, style='colormap', show_xlabel=True, show_ylabel=True)[source]¶ Visualize the data of the distribution in 1D or 2D, depending on the dimensionality of the underlaying distribution.
Parameters:
 fig : matplotlib Figure instance
 If given, use this figure instance for the visualization,
 ax : matplotlib Axes instance
 If given, render the visualization using this axis instance.
 figsize : tuple
 Size of the new Figure instance, if one needs to be created.
 colorbar: Bool
 Whether or not the colorbar (in 2D visualization) should be used.
 cmap: matplotlib colormap instance
 If given, use this colormap for 2D visualizations.
 style : string
 Type of visualization: ‘colormap’ (default) or ‘surface’.
Returns: fig, ax : tuple
A tuple of matplotlib figure and axes instances.


class
TwoModeQuadratureCorrelation
(state=None, theta1=0.0, theta2=0.0, extent=[[5, 5], [5, 5]], steps=250)[source]¶ 
update
(state)[source]¶ calculate probability distribution for quadrature measurement outcomes given a twomode wavefunction or density matrix

Quantum information processing¶

class
Gate
(name, targets=None, controls=None, arg_value=None, arg_label=None)[source]¶ Representation of a quantum gate, with its required parametrs, and target and control qubits.

class
QubitCircuit
(N, reverse_states=True)[source]¶ Representation of a quantum program/algorithm, maintaining a sequence of gates.

add_1q_gate
(name, start=0, end=None, qubits=None, arg_value=None, arg_label=None)[source]¶ Adds a single qubit gate with specified parameters on a variable number of qubits in the circuit. By default, it applies the given gate to all the qubits in the register.
Parameters: name : String
Gate name.
start : Integer
Starting location of qubits.
end : Integer
Last qubit for the gate.
qubits : List
Specific qubits for applying gates.
arg_value : Float
Argument value(phi).
arg_label : String
Label for gate representation.

add_circuit
(qc, start=0)[source]¶ Adds a block of a qubit circuit to the main circuit. Globalphase gates are not added.
Parameters: qc : QubitCircuit
The circuit block to be added to the main circuit.
start : Integer
The qubit on which the first gate is applied.

add_gate
(gate, targets=None, controls=None, arg_value=None, arg_label=None)[source]¶ Adds a gate with specified parameters to the circuit.
Parameters: gate: String or `Gate`
Gate name. If gate is an instance of Gate, parameters are unpacked and added.
targets: List
Gate targets.
controls: List
Gate controls.
arg_value: Float
Argument value(phi).
arg_label: String
Label for gate representation.

adjacent_gates
()[source]¶ Method to resolve two qubit gates with nonadjacent control/s or target/s in terms of gates with adjacent interactions.
Returns: qc : QubitCircuit
Returns QubitCircuit of the gates for the qubit circuit with the resolved nonadjacent gates.

propagators
()[source]¶ Propagator matrix calculator for N qubits returning the individual steps as unitary matrices operating from left to right.
Returns: U_list : list
Returns list of unitary matrices for the qubit circuit.

remove_gate
(index=None, end=None, name=None, remove='first')[source]¶ Removes a gate from a specific index or between two indexes or the first, last or all instances of a particular gate.
Parameters: index : Integer
Location of gate to be removed.
name : String
Gate name to be removed.
remove : String
If first or all gate are to be removed.

resolve_gates
(basis=['CNOT', 'RX', 'RY', 'RZ'])[source]¶ Unitary matrix calculator for N qubits returning the individual steps as unitary matrices operating from left to right in the specified basis.
Parameters: basis : list.
Basis of the resolved circuit.
Returns: qc : QubitCircuit
Returns QubitCircuit of resolved gates for the qubit circuit in the desired basis.


class
CircuitProcessor
(N, correct_global_phase)[source]¶ Base class for representation of the physical implementation of a quantum program/algorithm on a specified qubit system.

adjacent_gates
(qc, setup)[source]¶ Function to take a quantum circuit/algorithm and convert it into the optimal form/basis for the desired physical system.
Parameters: qc: QubitCircuit
Takes the quantum circuit to be implemented.
setup: String
Takes the nature of the spin chain; linear or circular.
Returns: qc: QubitCircuit
The resolved circuit representation.

get_ops_and_u
()[source]¶ Returns the Hamiltonian operators and corresponding values by stacking them together.

get_ops_labels
()[source]¶ Returns the Hamiltonian operators and corresponding labels by stacking them together.

load_circuit
(qc)[source]¶ Translates an abstract quantum circuit to its corresponding Hamiltonian for a specific model.
Parameters: qc: QubitCircuit
Takes the quantum circuit to be implemented.

optimize_circuit
(qc)[source]¶ Function to take a quantum circuit/algorithm and convert it into the optimal form/basis for the desired physical system.
Parameters: qc: QubitCircuit
Takes the quantum circuit to be implemented.
Returns: qc: QubitCircuit
The optimal circuit representation.

plot_pulses
()[source]¶ Maps the physical interaction between the circuit components for the desired physical system.
Returns: fig, ax: Figure
Maps the physical interaction between the circuit components.

pulse_matrix
()[source]¶ Generates the pulse matrix for the desired physical system.
Returns: t, u, labels:
Returns the total time and label for every operation.

run
(qc=None)[source]¶ Generates the propagator matrix by running the Hamiltonian for the appropriate time duration for the desired physical system.
Parameters: qc: QubitCircuit
Takes the quantum circuit to be implemented.
Returns: U_list: list
The propagator matrix obtained from the physical implementation.

run_state
(qc=None, states=None)[source]¶ Generates the propagator matrix by running the Hamiltonian for the appropriate time duration for the desired physical system with the given initial state of the qubit register.
Parameters: qc: QubitCircuit
Takes the quantum circuit to be implemented.
states: Qobj
Initial state of the qubits in the register.
Returns: U_list: list
The propagator matrix obtained from the physical implementation.


class
SpinChain
(N, correct_global_phase=True, sx=None, sz=None, sxsy=None)[source]¶ Representation of the physical implementation of a quantum program/algorithm on a spin chain qubit system.

adjacent_gates
(qc, setup='linear')[source]¶ Method to resolve 2 qubit gates with nonadjacent control/s or target/s in terms of gates with adjacent interactions for linear/circular spin chain system.
Parameters: qc: QubitCircuit
The circular spin chain circuit to be resolved
setup: Boolean
Linear of Circular spin chain setup
Returns: qc: QubitCircuit
Returns QubitCircuit of resolved gates for the qubit circuit in the desired basis.


class
LinearSpinChain
(N, correct_global_phase=True, sx=None, sz=None, sxsy=None)[source]¶ Representation of the physical implementation of a quantum program/algorithm on a spin chain qubit system arranged in a linear formation. It is a subclass of SpinChain.

class
CircularSpinChain
(N, correct_global_phase=True, sx=None, sz=None, sxsy=None)[source]¶ Representation of the physical implementation of a quantum program/algorithm on a spin chain qubit system arranged in a circular formation. It is a subclass of SpinChain.

class
DispersivecQED
(N, correct_global_phase=True, Nres=None, deltamax=None, epsmax=None, w0=None, wq=None, eps=None, delta=None, g=None)[source]¶ Representation of the physical implementation of a quantum program/algorithm on a dispersive cavityQED system.

dispersive_gate_correction
(qc1, rwa=True)[source]¶ Method to resolve ISWAP and SQRTISWAP gates in a cQED system by adding single qubit gates to get the correct output matrix.
Parameters: qc: Qobj
The circular spin chain circuit to be resolved
rwa: Boolean
Specify if RWA is used or not.
Returns: qc: QubitCircuit
Returns QubitCircuit of resolved gates for the qubit circuit in the desired basis.

Optimal control¶

class
Optimizer
(config, dyn, params=None)[source]¶ Base class for all control pulse optimisers. This class should not be instantiated, use its subclasses This class implements the fidelity, gradient and interation callback functions. All subclass objects must be initialised with a
OptimConfig instance  various configuration options Dynamics instance  describes the dynamics of the (quantum) system
to be control optimisedAttributes
dumping
log_level (integer) level of messaging output from the logger. Options are attributes of qutip.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN params: Dictionary The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do. alg (string) Algorithm to use in pulse optimisation. Options are: ‘GRAPE’ (default)  GRadient Ascent Pulse Engineering ‘CRAB’  Chopped RAndom Basis alg_params (Dictionary) options that are specific to the pulse optim algorithm that is GRAPE or CRAB disp_conv_msg (bool) Set true to display a convergence message (for scipy.optimize.minimize methods anyway) optim_method (string) a scipy.optimize.minimize method that will be used to optimise the pulse for minimum fidelity error method_params (Dictionary) Options for the optim_method. Note that where there is an equivalent attribute of this instance or the termination_conditions (for example maxiter) it will override an value in these options approx_grad (bool) If set True then the method will approximate the gradient itself (if it has requirement and facility for this) This will mean that the fid_err_grad_wrapper will not get called Note it should be left False when using the Dynamics to calculate approximate gradients Note it is set True automatically when the alg is CRAB amp_lbound (float or list of floats) lower boundaries for the control amplitudes Can be a scalar value applied to all controls or a list of bounds for each control amp_ubound (float or list of floats) upper boundaries for the control amplitudes Can be a scalar value applied to all controls or a list of bounds for each control bounds (List of floats) Bounds for the parameters. If not set before the run_optimization call then the list is built automatically based on the amp_lbound and amp_ubound attributes. Setting this attribute directly allows specific bounds to be set for individual parameters. Note: Only some methods use bounds dynamics (Dynamics (subclass instance)) describes the dynamics of the (quantum) system to be control optimised (see Dynamics classes for details) config (OptimConfig instance) various configuration options (see OptimConfig for details) termination_conditions (TerminationCondition instance) attributes determine when the optimisation will end pulse_generator (PulseGen (subclass instance)) (can be) used to create initial pulses not used by the class, but set by pulseoptim.create_pulse_optimizer stats (Stats) attributes of which give performance stats for the optimisation set to None to reduce overhead of calculating stats. Note it is (usually) shared with the Dynamics instance dump ( dump.OptimDump
) Container for data dumped during the optimisation. Can be set by specifying the dumping level or set directly. Note this is mainly intended for user and a development debugging but could be used for status information during a long optimisation.dump_to_file (bool) If set True then data will be dumped to file during the optimisation dumping will be set to SUMMARY during init_optim if dump_to_file is True and dumping not set. Default is False dump_dir (string) Basically a link to dump.dump_dir. Exists so that it can be set through optim_params. If dump is None then will return None or will set dumping to SUMMARY when setting a path iter_summary ( OptimIterSummary
) Summary of the most recent iteration. Note this is only set if dummping is on
apply_method_params
(params=None)[source]¶ Loops through all the method_params (either passed here or the method_params attribute) If the name matches an attribute of this object or the termination conditions object, then the value of this attribute is set. Otherwise it is assumed to a method_option for the scipy.optimize.minimize function

apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do.

dumping
¶  The level of data dumping that will occur during the optimisation
 NONE : No processing data dumped (Default)
 SUMMARY : A summary at each iteration will be recorded
 FULL : All logs will be generated and dumped
 CUSTOM : Some customised level of dumping
When first set to CUSTOM this is equivalent to SUMMARY. It is then up to the user to specify which logs are dumped

fid_err_func_wrapper
(*args)[source]¶ Get the fidelity error achieved using the ctrl amplitudes passed in as the first argument.
This is called by generic optimisation algorithm as the func to the minimised. The argument is the current variable values, i.e. control amplitudes, passed as a flat array. Hence these are reshaped as [nTimeslots, n_ctrls] and then used to update the stored ctrl values (if they have changed)
The error is checked against the target, and the optimisation is terminated if the target has been achieved.

fid_err_grad_wrapper
(*args)[source]¶ Get the gradient of the fidelity error with respect to all of the variables, i.e. the ctrl amplidutes in each timeslot
This is called by generic optimisation algorithm as the gradients of func to the minimised wrt the variables. The argument is the current variable values, i.e. control amplitudes, passed as a flat array. Hence these are reshaped as [nTimeslots, n_ctrls] and then used to update the stored ctrl values (if they have changed)
Although the optimisation algorithms have a check within them for function convergence, i.e. local minima, the sum of the squares of the normalised gradient is checked explicitly, and the optimisation is terminated if this is below the min_gradient_norm condition

init_optim
(term_conds)[source]¶ Check optimiser attribute status and passed parameters before running the optimisation. This is called by run_optimization, but could called independently to check the configuration.

iter_step_callback_func
(*args)[source]¶ Check the elapsed wall time for the optimisation run so far. Terminate if this has exceeded the maximum allowed time

run_optimization
(term_conds=None)[source]¶ This default function optimisation method is a wrapper to the scipy.optimize.minimize function.
It will attempt to minimise the fidelity error with respect to some parameters, which are determined by _get_optim_var_vals (see below)
The optimisation end when one of the passed termination conditions has been met, e.g. target achieved, wall time, or function call or iteration count exceeded. Note these conditions include gradient minimum met (local minima) for methods that use a gradient.
The function minimisation method is taken from the optim_method attribute. Note that not all of these methods have been tested. Note that some of these use a gradient and some do not. See the scipy documentation for details. Options specific to the method can be passed setting the method_params attribute.
If the parameter term_conds=None, then the termination_conditions attribute must already be set. It will be overwritten if the parameter is not None
The result is returned in an OptimResult object, which includes the final fidelity, time evolution, reason for termination etc


class
OptimizerBFGS
(config, dyn, params=None)[source]¶ Implements the run_optimization method using the BFGS algorithm

run_optimization
(term_conds=None)[source]¶ Optimise the control pulse amplitudes to minimise the fidelity error using the BFGS (Broyden–Fletcher–Goldfarb–Shanno) algorithm The optimisation end when one of the passed termination conditions has been met, e.g. target achieved, gradient minimum met (local minima), wall time / iteration count exceeded.
Essentially this is wrapper to the: scipy.optimize.fmin_bfgs function
If the parameter term_conds=None, then the termination_conditions attribute must already be set. It will be overwritten if the parameter is not None
The result is returned in an OptimResult object, which includes the final fidelity, time evolution, reason for termination etc


class
OptimizerLBFGSB
(config, dyn, params=None)[source]¶ Implements the run_optimization method using the LBFGSB algorithm
Attributes
max_metric_corr (integer) The maximum number of variable metric corrections used to define the limited memory matrix. That is the number of previous gradient values that are used to approximate the Hessian see the scipy.optimize.fmin_l_bfgs_b documentation for description of m argument 
init_optim
(term_conds)[source]¶ Check optimiser attribute status and passed parameters before running the optimisation. This is called by run_optimization, but could called independently to check the configuration.

run_optimization
(term_conds=None)[source]¶ Optimise the control pulse amplitudes to minimise the fidelity error using the LBFGSB algorithm, which is the constrained (bounded amplitude values), limited memory, version of the Broyden–Fletcher–Goldfarb–Shanno algorithm.
The optimisation end when one of the passed termination conditions has been met, e.g. target achieved, gradient minimum met (local minima), wall time / iteration count exceeded.
Essentially this is wrapper to the: scipy.optimize.fmin_l_bfgs_b function This in turn is a warpper for well established implementation of the LBFGSB algorithm written in Fortran, which is therefore very fast. See SciPy documentation for credit and details on this function.
If the parameter term_conds=None, then the termination_conditions attribute must already be set. It will be overwritten if the parameter is not None
The result is returned in an OptimResult object, which includes the final fidelity, time evolution, reason for termination etc


class
OptimizerCrab
(config, dyn, params=None)[source]¶ Optimises the pulse using the CRAB algorithm [1]. It uses the scipy.optimize.minimize function with the method specified by the optim_method attribute. See Optimizer.run_optimization for details It minimises the fidelity error function with respect to the CRAB basis function coefficients.
AJGP ToDo: Add citation here

class
OptimizerCrabFmin
(config, dyn, params=None)[source]¶ Optimises the pulse using the CRAB algorithm [1, 2]. It uses the scipy.optimize.fmin function which is effectively a wrapper for the Neldermead method. It minimises the fidelity error function with respect to the CRAB basis function coefficients. This is the default Optimizer for CRAB.
Notes
 [1] P. Doria, T. Calarco & S. Montangero. Phys. Rev. Lett. 106,
 190501 (2011).
[2] T. Caneva, T. Calarco, & S. Montangero. Phys. Rev. A 84, 022326 (2011).

run_optimization
(term_conds=None)[source]¶ This function optimisation method is a wrapper to the scipy.optimize.fmin function.
It will attempt to minimise the fidelity error with respect to some parameters, which are determined by _get_optim_var_vals which in the case of CRAB are the basis function coefficients
The optimisation end when one of the passed termination conditions has been met, e.g. target achieved, wall time, or function call or iteration count exceeded. Specifically to the fmin method, the optimisation will stop when change parameter values is less than xtol or the change in function value is below ftol.
If the parameter term_conds=None, then the termination_conditions attribute must already be set. It will be overwritten if the parameter is not None
The result is returned in an OptimResult object, which includes the final fidelity, time evolution, reason for termination etc

class
OptimIterSummary
[source]¶ A summary of the most recent iteration of the pulse optimisation
Attributes
iter_num (int) Iteration number of the pulse optimisation fid_func_call_num (int) Fidelity function call number of the pulse optimisation grad_func_call_num (int) Gradient function call number of the pulse optimisation fid_err (float) Fidelity error grad_norm (float) fidelity gradient (wrt the control parameters) vector norm that is the magnitude of the gradient wall_time (float) Time spent computing the pulse optimisation so far (in seconds of elapsed time)

class
TerminationConditions
[source]¶ Base class for all termination conditions Used to determine when to stop the optimisation algorithm Note different subclasses should be used to match the type of optimisation being used
Attributes
fid_err_targ (float) Target fidelity error fid_goal (float) goal fidelity, e.g. 1  self.fid_err_targ It its typical to set this for unitary systems max_wall_time (float) # maximum time for optimisation (seconds) min_gradient_norm (float) Minimum normalised gradient after which optimisation will terminate max_iterations (integer) Maximum iterations of the optimisation algorithm max_fid_func_calls (integer) Maximum number of calls to the fidelity function during the optimisation algorithm accuracy_factor (float) Determines the accuracy of the result. Typical values for accuracy_factor are: 1e12 for low accuracy; 1e7 for moderate accuracy; 10.0 for extremely high accuracy scipy.optimize.fmin_l_bfgs_b factr argument. Only set for specific methods (fmin_l_bfgs_b) that uses this Otherwise the same thing is passed as method_option ftol (although the scale is different) Hence it is not defined here, but may be set by the user

class
OptimResult
[source]¶ Attributes give the result of the pulse optimisation attempt
Attributes
termination_reason (string) Description of the reason for terminating the optimisation fidelity (float) final (normalised) fidelity that was achieved initial_fid_err (float) fidelity error before optimisation starting fid_err (float) final fidelity error that was achieved goal_achieved (boolean) True is the fidely error achieved was below the target grad_norm_final (float) Final value of the sum of the squares of the (normalised) fidelity error gradients grad_norm_min_reached (float) True if the optimisation terminated due to the minimum value of the gradient being reached num_iter (integer) Number of iterations of the optimisation algorithm completed max_iter_exceeded (boolean) True if the iteration limit was reached max_fid_func_exceeded (boolean) True if the fidelity function call limit was reached wall_time (float) time elapsed during the optimisation wall_time_limit_exceeded (boolean) True if the wall time limit was reached time (array[num_tslots+1] of float) Time are the start of each timeslot with the final value being the total evolution time initial_amps (array[num_tslots, n_ctrls]) The amplitudes at the start of the optimisation final_amps (array[num_tslots, n_ctrls]) The amplitudes at the end of the optimisation evo_full_final (Qobj) The evolution operator from t=0 to t=T based on the final amps stats (Stats) Object contaning the stats for the run (if any collected) optimizer (Optimizer) Instance of the Optimizer used to generate the result

class
Dynamics
(optimconfig, params=None)[source]¶ This is a base class only. See subclass descriptions and choose an appropriate one for the application.
Note that initialize_controls must be called before most of the methods can be used. init_timeslots can be called sometimes earlier in order to access timeslot related attributes
This acts as a container for the operators that are used to calculate time evolution of the system under study. That is the dynamics generators (Hamiltonians, Lindbladians etc), the propagators from one timeslot to the next, and the evolution operators. Due to the large number of matrix additions and multiplications, for small systems at least, the optimisation performance is much better using ndarrays to represent these operators. However
Attributes
num_ctrls
dyn_gen
prop
prop_grad
fwd_evo
onwd_evo
onto_evo
dumping
log_level (integer) level of messaging output from the logger. Options are attributes of qutip.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN params: Dictionary The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do. stats (Stats) Attributes of which give performance stats for the optimisation set to None to reduce overhead of calculating stats. Note it is (usually) shared with the Optimizer object tslot_computer (TimeslotComputer (subclass instance)) Used to manage when the timeslot dynamics generators, propagators, gradients etc are updated prop_computer (PropagatorComputer (subclass instance)) Used to compute the propagators and their gradients fid_computer (FidelityComputer (subclass instance)) Used to computer the fidelity error and the fidelity error gradient. memory_optimization (int) Level of memory optimisation. Setting to 0 (default) means that execution speed is prioritized over memory. Setting to 1 means that some memory prioritisation steps will be taken, for instance using Qobj (and hence sparse arrays) as the the internal operator data type, and not caching some operators Potentially further memory saving maybe made with memory_optimization > 1. The options are processed in _set_memory_optimizations, see this for more information. Individual memory saving options can be switched by settting them directly (see below) oper_dtype (type) Data type for internal dynamics generators, propagators and time evolution operators. This can be ndarray or Qobj, or (in theory) any other representaion that supports typical matrix methods (e.g. dot) ndarray performs best for smaller quantum systems. Qobj may perform better for larger systems, and will also perform better when (custom) fidelity measures use Qobj methods such as partial trace. See _choose_oper_dtype for how this is chosen when not specified cache_phased_dyn_gen (bool) If True then the dynamics generators will be saved with and without the propagation prefactor (if there is one) Defaults to True when memory_optimization=0, otherwise False cache_prop_grad (bool) If the True then the propagator gradients (for exact gradients) will be computed when the propagator are computed and cache until the are used by the fidelity computer. If False then the fidelity computer will calculate them as needed. Defaults to True when memory_optimization=0, otherwise False cache_dyn_gen_eigenvectors_adj: bool If True then DynamicsUnitary will cached the adjoint of the Hamiltion eignvector matrix Defaults to True when memory_optimization=0, otherwise False sparse_eigen_decomp: bool If True then DynamicsUnitary will use the sparse eigenvalue decomposition. Defaults to True when memory_optimization<=1, otherwise False num_tslots (integer) Number of timeslots (aka timeslices) evo_time (float) Total time for the evolution tau (array[num_tslots] of float) Duration of each timeslot Note that if this is set before initialize_controls is called then num_tslots and evo_time are calculated from tau, otherwise tau is generated from num_tslots and evo_time, that is equal size time slices time (array[num_tslots+1] of float) Cumulative time for the evolution, that is the time at the start of each time slice drift_dyn_gen (Qobj or list of Qobj) Drift or system dynamics generator (Hamiltonian) Matrix defining the underlying dynamics of the system Can also be a list of Qobj (length num_tslots) for time varying drift dynamics ctrl_dyn_gen (List of Qobj) Control dynamics generator (Hamiltonians) List of matrices defining the control dynamics initial (Qobj) Starting state / gate The matrix giving the initial state / gate, i.e. at time 0 Typically the identity for gate evolution target (Qobj) Target state / gate: The matrix giving the desired state / gate for the evolution ctrl_amps (array[num_tslots, num_ctrls] of float) Control amplitudes The amplitude (scale factor) for each control in each timeslot initial_ctrl_scaling (float) Scale factor applied to be applied the control amplitudes when they are initialised This is used by the PulseGens rather than in any fucntions in this class initial_ctrl_offset (float) Linear offset applied to be applied the control amplitudes when they are initialised This is used by the PulseGens rather than in any fucntions in this class evo_current (Boolean) Used to flag that the dynamics used to calculate the evolution operators is current. It is set to False when the amplitudes change fact_mat_round_prec (float) Rounding precision used when calculating the factor matrix to determine if two eigenvalues are equivalent Only used when the PropagatorComputer uses diagonalisation def_amps_fname (string) Default name for the output used when save_amps is called unitarity_check_level (int) If > 0 then unitarity of the system evolution is checked at at evolution recomputation. level 1 checks all propagators level 2 checks eigen basis as well Default is 0 unitarity_tol : Tolerance used in checking if operator is unitary Default is 1e10 dump ( dump.DynamicsDump
) Store of historical calculation data. Set to None (Default) for no storing of historical data Use dumping property to set level of data dumpingdump_to_file (bool) If set True then data will be dumped to file during the calculations dumping will be set to SUMMARY during init_evo if dump_to_file is True and dumping not set. Default is False dump_dir (string) Basically a link to dump.dump_dir. Exists so that it can be set through dyn_params. If dump is None then will return None or will set dumping to SUMMARY when setting a path 
apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do.

combine_dyn_gen
(k)[source]¶ Computes the dynamics generator for a given timeslot The is the combined Hamiltion for unitary systems

compute_evolution
()[source]¶ Recalculate the time evolution operators Dynamics generators (e.g. Hamiltonian) and prop (propagators) are calculated as necessary Actual work is completed by the recompute_evolution method of the timeslot computer

dumping
¶ The level of data dumping that will occur during the time evolution calculation.
 NONE : No processing data dumped (Default)
 SUMMARY : A summary of each time evolution will be recorded
 FULL : All operators used or created in the calculation dumped
 CUSTOM : Some customised level of dumping
When first set to CUSTOM this is equivalent to SUMMARY. It is then up to the user to specify which operators are dumped WARNING: FULL could consume a lot of memory!

dyn_gen
¶ List of combined dynamics generators (Qobj) for each timeslot

dyn_gen_phase
¶ Some preop that is applied to the dyn_gen before expontiating to get the propagator

full_evo
¶ Full evolution  time evolution at final time slot

fwd_evo
¶ List of evolution operators (Qobj) from the initial to the given timeslot

get_ctrl_dyn_gen
(j)[source]¶ Get the dynamics generator for the control Not implemented in the base class. Choose a subclass

get_drift_dim
()[source]¶ Returns the size of the matrix that defines the drift dynamics that is assuming the drift is NxN, then this returns N

get_dyn_gen
(k)[source]¶ Get the combined dynamics generator for the timeslot Not implemented in the base class. Choose a subclass

get_num_ctrls
()[source]¶ calculate the of controls from the length of the control list sets the num_ctrls property, which can be used alternatively subsequently

init_timeslots
()[source]¶ Generate the timeslot duration array ‘tau’ based on the evo_time and num_tslots attributes, unless the tau attribute is already set in which case this step in ignored Generate the cumulative time array ‘time’ based on the tau values

initialize_controls
(amps, init_tslots=True)[source]¶ Set the initial control amplitudes and time slices Note this must be called after the configuration is complete before any dynamics can be calculated

num_ctrls
¶ calculate the of controls from the length of the control list sets the num_ctrls property, which can be used alternatively subsequently

onto_evo
¶ List of evolution operators (Qobj) from the initial to the given timeslot

onwd_evo
¶ List of evolution operators (Qobj) from the initial to the given timeslot

prop
¶ List of propagators (Qobj) for each timeslot

prop_grad
¶ Array of propagator gradients (Qobj) for each timeslot, control

save_amps
(file_name=None, times=None, amps=None, verbose=False)[source]¶ Save a file with the current control amplitudes in each timeslot The first column in the file will be the start time of the slot
Parameters: file_name : string
Name of the file If None given the def_amps_fname attribuite will be used
times : List type (or string)
List / array of the start times for each slot If None given this will be retrieved through get_amp_times() If ‘exclude’ then times will not be saved in the file, just the amplitudes
amps : Array[num_tslots, num_ctrls]
Amplitudes to be saved If None given the ctrl_amps attribute will be used
verbose : Boolean
If True then an info message will be logged


class
DynamicsGenMat
(optimconfig, params=None)[source]¶ This sub class can be used for any system where no additional operator is applied to the dynamics generator before calculating the propagator, e.g. classical dynamics, Lindbladian

class
DynamicsUnitary
(optimconfig, params=None)[source]¶ This is the subclass to use for systems with dynamics described by unitary matrices. E.g. closed systems with Hermitian Hamiltonians Note a matrix diagonalisation is used to compute the exponent The eigen decomposition is also used to calculate the propagator gradient. The method is taken from DYNAMO (see file header)
Attributes
drift_ham (Qobj) This is the drift Hamiltonian for unitary dynamics It is mapped to drift_dyn_gen during initialize_controls ctrl_ham (List of Qobj) These are the control Hamiltonians for unitary dynamics It is mapped to ctrl_dyn_gen during initialize_controls H (List of Qobj) The combined drift and control Hamiltonians for each timeslot These are the dynamics generators for unitary dynamics. It is mapped to dyn_gen during initialize_controls

class
DynamicsSymplectic
(optimconfig, params=None)[source]¶ Symplectic systems This is the subclass to use for systems where the dynamics is described by symplectic matrices, e.g. coupled oscillators, quantum optics
Attributes
omega (array[drift_dyn_gen.shape]) matrix used in the calculation of propagators (time evolution) with symplectic systems. 
dyn_gen_phase
¶ The prephasing operator for the symplectic group generators usually refered to as Omega


class
PropagatorComputer
(dynamics, params=None)[source]¶ Base for all Propagator Computer classes that are used to calculate the propagators, and also the propagator gradient when exact gradient methods are used Note: they must be instantiated with a Dynamics object, that is the container for the data that the functions operate on This base class cannot be used directly. See subclass descriptions and choose the appropriate one for the application
Attributes
log_level (integer) level of messaging output from the logger. Options are attributes of qutip_utils.logging, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN grad_exact (boolean) indicates whether the computer class instance is capable of computing propagator gradients. It is used to determine whether to create the Dynamics prop_grad array 
apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do.


class
PropCompApproxGrad
(dynamics, params=None)[source]¶ This subclass can be used when the propagator is calculated simply by expm of the dynamics generator, i.e. when gradients will be calculated using approximate methods.

class
PropCompDiag
(dynamics, params=None)[source]¶ Coumputes the propagator exponentiation using diagonalisation of of the dynamics generator

class
PropCompFrechet
(dynamics, params=None)[source]¶  Frechet method for calculating the propagator:
 exponentiating the combined dynamics generator
and the propagator gradient It should work for all systems, e.g. unitary, open, symplectic There are other PropagatorComputer subclasses that may be more efficient

class
FidelityComputer
(dynamics, params=None)[source]¶ Base class for all Fidelity Computers. This cannot be used directly. See subclass descriptions and choose one appropriate for the application Note: this must be instantiated with a Dynamics object, that is the container for the data that the methods operate on
Attributes
log_level (integer) level of messaging output from the logger. Options are attributes of qutip.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN dimensional_norm (float) Normalisation constant fid_norm_func (function) Used to normalise the fidelity See SU and PSU options for the unitary dynamics grad_norm_func (function) Used to normalise the fidelity gradient See SU and PSU options for the unitary dynamics uses_onwd_evo (boolean) flag to specify whether the onwd_evo evolution operator (see Dynamics) is used by the FidelityComputer uses_onto_evo (boolean) flag to specify whether the onto_evo evolution operator (see Dynamics) is used by the FidelityComputer fid_err (float) Last computed value of the fidelity error fidelity (float) Last computed value of the normalised fidelity fidelity_current (boolean) flag to specify whether the fidelity / fid_err are based on the current amplitude values. Set False when amplitudes change fid_err_grad: array[num_tslot, num_ctrls] of float Last computed values for the fidelity error gradients wrt the control in the timeslot grad_norm (float) Last computed value for the norm of the fidelity error gradients (sqrt of the sum of the squares) fid_err_grad_current (boolean) flag to specify whether the fidelity / fid_err are based on the current amplitude values. Set False when amplitudes change 
apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do.


class
FidCompUnitary
(dynamics, params=None)[source]¶ Computes fidelity error and gradient assuming unitary dynamics, e.g. closed qubit systems Note fidelity and gradient calculations were taken from DYNAMO (see file header)
Attributes
phase_option (string) determines how global phase is treated in fidelity calculations: PSU  global phase ignored SU  global phase included fidelity_prenorm (complex) Last computed value of the fidelity before it is normalised It is stored to use in the gradient normalisation calculation fidelity_prenorm_current (boolean) flag to specify whether fidelity_prenorm are based on the current amplitude values. Set False when amplitudes change 
compute_fid_grad
()[source]¶ Calculates exact gradient of function wrt to each timeslot control amplitudes. Note these gradients are not normalised These are returned as a (nTimeslots x n_ctrls) array

get_fid_err_gradient
()[source]¶ Returns the normalised gradient of the fidelity error in a (nTimeslots x n_ctrls) array The gradients are cached in case they are requested mutliple times between control updates (although this is not typically found to happen)

get_fidelity
()[source]¶ Gets the appropriately normalised fidelity value The normalisation is determined by the fid_norm_func pointer which should be set in the config

get_fidelity_prenorm
()[source]¶ Gets the current fidelity value prior to normalisation Note the gradient function uses this value The value is cached, because it is used in the gradient calculation

init_normalization
()[source]¶ Calc norm of <Ufinal  Ufinal> to scale subsequent norms When considering unitary time evolution operators, this basically results in calculating the trace of the identity matrix and is hence equal to the size of the target matrix There may be situations where this is not the case, and hence it is not assumed to be so. The normalisation function called should be set to either the PSU  global phase ignored SU  global phase respected

normalize_gradient_PSU
(grad)[source]¶ Normalise the gradient matrix passed as grad This PSU version is independent of global phase


class
FidCompTraceDiff
(dynamics, params=None)[source]¶ Computes fidelity error and gradient for general system dynamics by calculating the the fidelity error as the trace of the overlap of the difference between the target and evolution resulting from the pulses with the transpose of the same. This should provide a distance measure for dynamics described by matrices Note the gradient calculation is taken from: ‘Robust quantum gates for open systems via optimal control: Markovian versus nonMarkovian dynamics’ Frederik F Floether, Pierre de Fouquieres, and Sophie G Schirmer
Attributes
scale_factor (float) The fidelity error calculated is of some arbitary scale. This factor can be used to scale the fidelity error such that it may represent some physical measure If None is given then it is caculated as 1/2N, where N is the dimension of the drift, when the Dynamics are initialised. 
compute_fid_err_grad
()[source]¶ Calculate exact gradient of the fidelity error function wrt to each timeslot control amplitudes. Uses the trace difference norm fidelity These are returned as a (nTimeslots x n_ctrls) array


class
FidCompTraceDiffApprox
(dynamics, params=None)[source]¶ As FidCompTraceDiff, except uses the finite difference method to compute approximate gradients
Attributes
epsilon (float) control amplitude offset to use when approximating the gradient wrt a timeslot control amplitude

class
TimeslotComputer
(dynamics, params=None)[source]¶ Base class for all Timeslot Computers Note: this must be instantiated with a Dynamics object, that is the container for the data that the methods operate on
Attributes
log_level (integer) level of messaging output from the logger. Options are attributes of qutip.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN evo_comp_summary (EvoCompSummary) A summary of the most recent evolution computation Used in the stats and dump Will be set to None if neither stats or dump are set 
apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value Note: attributes are created if they do not exist already, and are overwritten if they do.


class
TSlotCompUpdateAll
(dynamics, params=None)[source]¶ Timeslot Computer  Update All Updates all dynamics generators, propagators and evolutions when ctrl amplitudes are updated

compare_amps
(new_amps)[source]¶ Determine if any amplitudes have changed. If so, then mark the timeslots as needing recalculation Returns: True if amplitudes are the same, False if they have changed


class
PulseGen
(dyn=None, params=None)[source]¶ Pulse generator Base class for all Pulse generators The object can optionally be instantiated with a Dynamics object, in which case the timeslots and amplitude scaling and offset are copied from that. Otherwise the class can be used independently by setting: tau (array of timeslot durations) or num_tslots and pulse_time for equally spaced timeslots
Attributes
num_tslots (integer) Number of timeslots, aka timeslices (copied from Dynamics if given) pulse_time (float) total duration of the pulse (copied from Dynamics.evo_time if given) scaling (float) linear scaling applied to the pulse (copied from Dynamics.initial_ctrl_scaling if given) offset (float) linear offset applied to the pulse (copied from Dynamics.initial_ctrl_offset if given) tau (array[num_tslots] of float) Duration of each timeslot (copied from Dynamics if given) lbound (float) Lower boundary for the pulse amplitudes Note that the scaling and offset attributes can be used to fully bound the pulse for all generators except some of the random ones This bound (if set) may result in additional shifting / scaling Default is Inf ubound (float) Upper boundary for the pulse amplitudes Note that the scaling and offset attributes can be used to fully bound the pulse for all generators except some of the random ones This bound (if set) may result in additional shifting / scaling Default is Inf periodic (boolean) True if the pulse generator produces periodic pulses random (boolean) True if the pulse generator produces random pulses log_level (integer) level of messaging output from the logger. Options are attributes of qutip.logging_utils, in decreasing levels of messaging, are: DEBUG_INTENSE, DEBUG_VERBOSE, DEBUG, INFO, WARN, ERROR, CRITICAL Anything WARN or above is effectively ‘quiet’ execution, assuming everything runs as expected. The default NOTSET implies that the level will be taken from the QuTiP settings file, which by default is WARN 
apply_params
(params=None)[source]¶ Set object attributes based on the dictionary (if any) passed in the instantiation, or passed as a parameter This is called during the instantiation automatically. The key value pairs are the attribute name and value


class
PulseGenRandom
(dyn=None, params=None)[source]¶ Generates random pulses as simply random values for each timeslot

class
PulseGenLinear
(dyn=None, params=None)[source]¶ Generates linear pulses
Attributes
gradient (float) Gradient of the line. Note this is calculated from the start_val and end_val if these are given start_val (float) Start point of the line. That is the starting amplitude end_val (float) End point of the line. That is the amplitude at the start of the last timeslot 
gen_pulse
(gradient=None, start_val=None, end_val=None)[source]¶ Generate a linear pulse using either the gradient and start value or using the end point to calulate the gradient Note that the scaling and offset parameters are still applied, so unless these values are the default 1.0 and 0.0, then the actual gradient etc will be different Returns the pulse as an array of vales for each timeslot


class
PulseGenPeriodic
(dyn=None, params=None)[source]¶ Intermediate class for all periodic pulse generators All of the periodic pulses range from 1 to 1 All have a start phase that can be set between 0 and 2pi
Attributes
num_waves (float) Number of complete waves (cycles) that occur in the pulse. wavelen and freq calculated from this if it is given wavelen (float) Wavelength of the pulse (assuming the speed is 1) freq is calculated from this if it is given freq (float) Frequency of the pulse start_phase (float) Phase of the pulse signal when t=0 
init_pulse
(num_waves=None, wavelen=None, freq=None, start_phase=None)[source]¶ Calculate the wavelength, frequency, number of waves etc from the each other and the other parameters If num_waves is given then the other parameters are worked from this Otherwise if the wavelength is given then it is the driver Otherwise the frequency is used to calculate wavelength and num_waves


class
PulseGenSine
(dyn=None, params=None)[source]¶ Generates sine wave pulses

gen_pulse
(num_waves=None, wavelen=None, freq=None, start_phase=None)[source]¶ Generate a sine wave pulse If no params are provided then the class object attributes are used. If they are provided, then these will reinitialise the object attribs. returns the pulse as an array of vales for each timeslot


class
PulseGenGaussian
(dyn=None, params=None)[source]¶ Generates pulses with a Gaussian profile

gen_pulse
(mean=None, variance=None)[source]¶ Generate a pulse with Gaussian shape. The peak is centre around the mean and the variance determines the breadth The scaling and offset attributes are applied as an amplitude and fixed linear offset. Note that the maximum amplitude will be scaling + offset.


class
PulseGenGaussianEdge
(dyn=None, params=None)[source]¶ Generate pulses with inverted Gaussian ramping in and out It’s intended use for a ramping modulation, which is often required in experimental setups.
Attributes
decay_time (float) Determines the ramping rate. It is approximately the time required to bring the pulse to full amplitude It is set to 1/10 of the pulse time by default

class
PulseGenCrab
(dyn=None, num_coeffs=None, params=None)[source]¶ Base class for all CRAB pulse generators Note these are more involved in the optimisation process as they are used to produce piecewise control amplitudes each time new optimisation parameters are tried
Attributes
num_coeffs (integer) Number of coefficients used for each basis function num_basis_funcs (integer) Number of basis functions In this case set at 2 and should not be changed coeffs (float array[num_coeffs, num_basis_funcs]) The basis coefficient values randomize_coeffs (bool) If True (default) then the coefficients are set to some random values when initialised, otherwise they will all be equal to self.scaling 
estimate_num_coeffs
(dim)[source]¶ Estimate the number coefficients based on the dimensionality of the system. :returns: num_coeffs – estimated number of coefficients :rtype: int

get_optim_var_vals
()[source]¶ Get the parameter values to be optimised :returns: :rtype: list (or 1d array) of floats


class
PulseGenCrabFourier
(dyn=None, num_coeffs=None, params=None)[source]¶ Generates a pulse using the Fourier basis functions, i.e. sin and cos
Attributes
freqs (float array[num_coeffs]) Frequencies for the basis functions randomize_freqs (bool) If True (default) the some random offset is applied to the frequencies 
gen_pulse
(coeffs=None)[source]¶ Generate a pulse using the Fourier basis with the freqs and coeffs attributes.
Parameters: coeffs : float array[num_coeffs, num_basis_funcs]
The basis coefficient values If given this overides the default and sets the attribute of the same name.


class
Stats
[source]¶ Base class for all optimisation statistics Used for configurations where all timeslots are updated each iteration e.g. exact gradients Note that all times are generated using timeit.default_timer() and are in seconds
Attributes
dyn_gen_name (string) Text used in some report functions. Makes sense to set it to ‘Hamiltonian’ when using unitary dynamics Default is simply ‘dynamics generator’ num_iter (integer) Number of iterations of the optimisation algorithm wall_time_optim_start (float) Start time for the optimisation wall_time_optim_end (float) End time for the optimisation wall_time_optim (float) Time elasped during the optimisation wall_time_dyn_gen_compute (float) Total wall (elasped) time computing combined dynamics generator (for example combining drift and control Hamiltonians) wall_time_prop_compute (float) Total wall (elasped) time computing propagators, that is the time evolution from one timeslot to the next Includes calculating the propagator gradient for exact gradients wall_time_fwd_prop_compute (float) Total wall (elasped) time computing combined forward propagation, that is the time evolution from the start to a specific timeslot. Excludes calculating the propagators themselves wall_time_onwd_prop_compute (float) Total wall (elasped) time computing combined onward propagation, that is the time evolution from a specific timeslot to the end time. Excludes calculating the propagators themselves wall_time_gradient_compute (float) Total wall (elasped) time computing the fidelity error gradient. Excludes calculating the propagator gradients (in exact gradient methods) num_fidelity_func_calls (integer) Number of calls to fidelity function by the optimisation algorithm num_grad_func_calls (integer) Number of calls to gradient function by the optimisation algorithm num_tslot_recompute (integer) Number of time the timeslot evolution is recomputed (It is only computed if any amplitudes changed since the last call) num_fidelity_computes (integer) Number of time the fidelity is computed (It is only computed if any amplitudes changed since the last call) num_grad_computes (integer) Number of time the gradient is computed (It is only computed if any amplitudes changed since the last call) num_ctrl_amp_updates (integer) Number of times the control amplitudes are updated mean_num_ctrl_amp_updates_per_iter (float) Mean number of control amplitude updates per iteration num_timeslot_changes (integer) Number of times the amplitudes of a any control in a timeslot changes mean_num_timeslot_changes_per_update (float) Mean average number of timeslot amplitudes that are changed per update num_ctrl_amp_changes (integer) Number of times individual control amplitudes that are changed mean_num_ctrl_amp_changes_per_update (float) Mean average number of control amplitudes that are changed per update

class
Dump
[source]¶ A container for dump items. The lists for dump items is depends on the type Note: abstract class
Attributes
level
parent (some control object (Dynamics or Optimizer)) aka the host. Object that generates the data that is dumped and is host to this dump object. dump_dir (str) directory where files (if any) will be written out the path and be relative or absolute use ~/ to specify user home directory Note: files are only written when write_to_file is True of writeout is called explicitly Defaults to ~/.qtrl_dump write_to_file (bool) When set True data and summaries (as configured) will be written interactively to file during the processing Set during instantiation by the host based on its dump_to_file attrib dump_file_ext (str) Default file extension for any file names that are auto generated fname_base (str) First part of any auto generated file names. This is usually overridden in the subclass dump_summary (bool) If True a summary is recorded each time a new item is added to the the dump. Default is True summary_sep (str) delimiter for the summary file. default is a space data_sep (str) delimiter for the data files (arrays saved to file). default is a space summary_file (str) File path for summary file. Automatically generated. Can be set specifically 
level
¶  The level of data dumping that will occur
 SUMMARY : A summary will be recorded
 FULL : All possible dumping
 CUSTOM : Some customised level of dumping
When first set to CUSTOM this is equivalent to SUMMARY. It is then up to the user to specify what specifically is dumped


class
OptimDump
(optim, level='SUMMARY')[source]¶ A container for dumps of optimisation data generated during the pulse optimisation.
Attributes
dump_summary (bool) When True summary items are appended to the iter_summary iter_summary (list of optimizer.OptimIterSummary
) Summary at each iterationdump_fid_err (bool) When True values are appended to the fid_err_log fid_err_log (list of float) Fidelity error at each call of the fid_err_func dump_grad_norm (bool) When True values are appended to the fid_err_log grad_norm_log (list of float) Gradient norm at each call of the grad_norm_log dump_grad (bool) When True values are appended to the grad_log grad_log (list of ndarray) Gradients at each call of the fid_grad_func 
dump_all
¶ True if everything (ignoring the summary) is to be dumped

dump_any
¶ True if anything other than the summary is to be dumped

writeout
(f=None)[source]¶ write all the logs and the summary out to file(s)
Parameters: f : filename or filehandle
If specified then all summary and object data will go in one file. If None is specified then type specific files will be generated in the dump_dir If a filehandle is specified then it must be a byte mode file as numpy.savetxt is used, and requires this.


class
DynamicsDump
(dynamics, level='SUMMARY')[source]¶ A container for dumps of dynamics data. Mainly time evolution calculations
Attributes
dump_summary (bool) If True a summary is recorded evo_summary (list of :class:`tslotcomp.EvoCompSummary’) Summary items are appended if dump_summary is True at each recomputation of the evolution. dump_amps (bool) If True control amplitudes are dumped dump_dyn_gen (bool) If True the dynamics generators (Hamiltonians) are dumped dump_prop (bool) If True propagators are dumped dump_prop_grad (bool) If True propagator gradients are dumped dump_fwd_evo (bool) If True forward evolution operators are dumped dump_onwd_evo (bool) If True onward evolution operators are dumped dump_onto_evo (bool) If True onto (or backward) evolution operators are dumped evo_dumps (list of EvoCompDumpItem
) A new dump item is appended at each recomputation of the evolution. That is if any of the calculation objects are to be dumped.
dump_all
¶ True if all of the calculation objects are to be dumped

dump_any
¶ True if any of the calculation objects are to be dumped

writeout
(f=None)[source]¶ write all the dump items and the summary out to file(s) :param f: If specified then all summary and object data will go in one file.
If None is specified then type specific files will be generated in the dump_dir If a filehandle is specified then it must be a byte mode file as numpy.savetxt is used, and requires this.


class
EvoCompDumpItem
(dump)[source]¶ A copy of all objects generated to calculate one time evolution Note the attributes are only set if the corresponding
DynamicsDump
dump_ attribute is set.
writeout
(f=None)[source]¶ write all the objects out to files
Parameters: f : filename or filehandle
If specified then all object data will go in one file. If None is specified then type specific files will be generated in the dump_dir If a filehandle is specified then it must be a byte mode file as numpy.savetxt is used, and requires this.
