# Functions¶

## Manipulation and Creation of States and Operators¶

### Quantum States¶

basis(N, n=0, offset=0)[source]

Generates the vector representation of a Fock state.

Parameters: N : int Number of Fock states in Hilbert space. n : int Integer corresponding to desired number state, defaults to 0 if omitted. offset : int (default 0) The lowest number state that is included in the finite number state representation of the state. state : qobj Qobj representing the requested number state |n>.

Notes

A subtle incompatibility with the quantum optics toolbox: In QuTiP:

basis(N, 0) = ground state


but in the qotoolbox:

basis(N, 1) = ground state


Examples

>>> basis(5,2)
Quantum object: dims = [, ], shape = [5, 1], type = ket
Qobj data =
[[ 0.+0.j]
[ 0.+0.j]
[ 1.+0.j]
[ 0.+0.j]
[ 0.+0.j]]

coherent(N, alpha, offset=0, method='operator')[source]

Generates a coherent state with eigenvalue alpha.

Constructed using displacement operator on vacuum state.

Parameters: N : int Number of Fock states in Hilbert space. alpha : float/complex Eigenvalue of coherent state. offset : int (default 0) The lowest number state that is included in the finite number state representation of the state. Using a non-zero offset will make the default method ‘analytic’. method : string {‘operator’, ‘analytic’} Method for generating coherent state. state : qobj Qobj quantum object for coherent state

Notes

Select method ‘operator’ (default) or ‘analytic’. With the ‘operator’ method, the coherent state is generated by displacing the vacuum state using the displacement operator defined in the truncated Hilbert space of size ‘N’. This method guarantees that the resulting state is normalized. With ‘analytic’ method the coherent state is generated using the analytical formula for the coherent state coefficients in the Fock basis. This method does not guarantee that the state is normalized if truncated to a small number of Fock states, but would in that case give more accurate coefficients.

Examples

>>> coherent(5,0.25j)
Quantum object: dims = [, ], shape = [5, 1], type = ket
Qobj data =
[[  9.69233235e-01+0.j        ]
[  0.00000000e+00+0.24230831j]
[ -4.28344935e-02+0.j        ]
[  0.00000000e+00-0.00618204j]
[  7.80904967e-04+0.j        ]]

coherent_dm(N, alpha, offset=0, method='operator')[source]

Density matrix representation of a coherent state.

Constructed via outer product of qutip.states.coherent

Parameters: N : int Number of Fock states in Hilbert space. alpha : float/complex Eigenvalue for coherent state. offset : int (default 0) The lowest number state that is included in the finite number state representation of the state. method : string {‘operator’, ‘analytic’} Method for generating coherent density matrix. dm : qobj Density matrix representation of coherent state.

Notes

Select method ‘operator’ (default) or ‘analytic’. With the ‘operator’ method, the coherent density matrix is generated by displacing the vacuum state using the displacement operator defined in the truncated Hilbert space of size ‘N’. This method guarantees that the resulting density matrix is normalized. With ‘analytic’ method the coherent density matrix is generated using the analytical formula for the coherent state coefficients in the Fock basis. This method does not guarantee that the state is normalized if truncated to a small number of Fock states, but would in that case give more accurate coefficients.

Examples

>>> coherent_dm(3,0.25j)
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
[ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
[-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j        ]]

fock(N, n=0, offset=0)[source]

Bosonic Fock (number) state.

Same as qutip.states.basis.

Parameters: N : int Number of states in the Hilbert space. n : int int for desired number state, defaults to 0 if omitted. Requested number state $$\left|n\right>$$.

Examples

>>> fock(4,3)
Quantum object: dims = [, ], shape = [4, 1], type = ket
Qobj data =
[[ 0.+0.j]
[ 0.+0.j]
[ 0.+0.j]
[ 1.+0.j]]

fock_dm(N, n=0, offset=0)[source]

Density matrix representation of a Fock state

Constructed via outer product of qutip.states.fock.

Parameters: N : int Number of Fock states in Hilbert space. n : int int for desired number state, defaults to 0 if omitted. dm : qobj Density matrix representation of Fock state.

Examples

>>> fock_dm(3,1)
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j]]

ket2dm(Q)[source]

Takes input ket or bra vector and returns density matrix formed by outer product.

Parameters: Q : qobj Ket or bra type quantum object. dm : qobj Density matrix formed by outer product of Q.

Examples

>>> x=basis(3,2)
>>> ket2dm(x)
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j]]

qutrit_basis()[source]

Basis states for a three level system (qutrit)

Returns: qstates : array Array of qutrit basis vectors
thermal_dm(N, n, method='operator')[source]

Density matrix for a thermal state of n particles

Parameters: N : int Number of basis states in Hilbert space. n : float Expectation value for number of particles in thermal state. method : string {‘operator’, ‘analytic’} string that sets the method used to generate the thermal state probabilities dm : qobj Thermal state density matrix.

Notes

The ‘operator’ method (default) generates the thermal state using the truncated number operator num(N). This is the method that should be used in computations. The ‘analytic’ method uses the analytic coefficients derived in an infinite Hilbert space. The analytic form is not necessarily normalized, if truncated too aggressively.

Examples

>>> thermal_dm(5, 1)
Quantum object: dims = [, ], shape = [5, 5], type = oper, isHerm = True
Qobj data =
[[ 0.51612903  0.          0.          0.          0.        ]
[ 0.          0.25806452  0.          0.          0.        ]
[ 0.          0.          0.12903226  0.          0.        ]
[ 0.          0.          0.          0.06451613  0.        ]
[ 0.          0.          0.          0.          0.03225806]]

>>> thermal_dm(5, 1, 'analytic')
Quantum object: dims = [, ], shape = [5, 5], type = oper, isHerm = True
Qobj data =
[[ 0.5      0.       0.       0.       0.     ]
[ 0.       0.25     0.       0.       0.     ]
[ 0.       0.       0.125    0.       0.     ]
[ 0.       0.       0.       0.0625   0.     ]
[ 0.       0.       0.       0.       0.03125]]

phase_basis(N, m, phi0=0)[source]

Basis vector for the mth phase of the Pegg-Barnett phase operator.

Parameters: N : int Number of basis vectors in Hilbert space. m : int Integer corresponding to the mth discrete phase phi_m=phi0+2*pi*m/N phi0 : float (default=0) Reference phase angle. state : qobj Ket vector for mth Pegg-Barnett phase operator basis state.

Notes

The Pegg-Barnett basis states form a complete set over the truncated Hilbert space.

state_number_enumerate(dims, excitations=None, state=None, idx=0)[source]

An iterator that enumerate all the state number arrays (quantum numbers on the form [n1, n2, n3, ...]) for a system with dimensions given by dims.

Example:

>>> for state in state_number_enumerate([2,2]):
>>>     print(state)
[ 0.  0.]
[ 0.  1.]
[ 1.  0.]
[ 1.  1.]

Parameters: dims : list or array The quantum state dimensions array, as it would appear in a Qobj. state : list Current state in the iteration. Used internally. excitations : integer (None) Restrict state space to states with excitation numbers below or equal to this value. idx : integer Current index in the iteration. Used internally. state_number : list Successive state number arrays that can be used in loops and other iterations, using standard state enumeration by definition.
state_number_index(dims, state)[source]

Return the index of a quantum state corresponding to state, given a system with dimensions given by dims.

Example:

>>> state_number_index([2, 2, 2], [1, 1, 0])
6.0

Parameters: dims : list or array The quantum state dimensions array, as it would appear in a Qobj. state : list State number array. idx : list The index of the state given by state in standard enumeration ordering.
state_index_number(dims, index)[source]

Return a quantum number representation given a state index, for a system of composite structure defined by dims.

Example:

>>> state_index_number([2, 2, 2], 6)
[1, 1, 0]

Parameters: dims : list or array The quantum state dimensions array, as it would appear in a Qobj. index : integer The index of the state in standard enumeration ordering. state : list The state number array corresponding to index index in standard enumeration ordering.
state_number_qobj(dims, state)[source]

Return a Qobj representation of a quantum state specified by the state array state.

Example:

>>> state_number_qobj([2, 2, 2], [1, 0, 1])
Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
Qobj data =
[[ 0.]
[ 0.]
[ 0.]
[ 0.]
[ 0.]
[ 1.]
[ 0.]
[ 0.]]

Parameters: dims : list or array The quantum state dimensions array, as it would appear in a Qobj. state : list State number array. state : qutip.Qobj.qobj The state as a qutip.Qobj.qobj instance.
enr_state_dictionaries(dims, excitations)[source]

Return the number of states, and lookup-dictionaries for translating a state tuple to a state index, and vice versa, for a system with a given number of components and maximum number of excitations.

Parameters: dims: list A list with the number of states in each sub-system. excitations : integer The maximum numbers of dimension nstates, state2idx, idx2state: integer, dict, dict The number of states nstates, a dictionary for looking up state indices from a state tuple, and a dictionary for looking up state state tuples from state indices.
enr_thermal_dm(dims, excitations, n)[source]

Generate the density operator for a thermal state in the excitation-number- restricted state space defined by the dims and exciations arguments. See the documentation for enr_fock for a more detailed description of these arguments. The temperature of each mode in dims is specified by the average number of excitatons n.

Parameters: dims : list A list of the dimensions of each subsystem of a composite quantum system. excitations : integer The maximum number of excitations that are to be included in the state space. n : integer The average number of exciations in the thermal state. n can be a float (which then applies to each mode), or a list/array of the same length as dims, in which each element corresponds specifies the temperature of the corresponding mode. dm : Qobj Thermal state density matrix.
enr_fock(dims, excitations, state)[source]

Generate the Fock state representation in a excitation-number restricted state space. The dims argument is a list of integers that define the number of quantums states of each component of a composite quantum system, and the excitations specifies the maximum number of excitations for the basis states that are to be included in the state space. The state argument is a tuple of integers that specifies the state (in the number basis representation) for which to generate the Fock state representation.

Parameters: dims : list A list of the dimensions of each subsystem of a composite quantum system. excitations : integer The maximum number of excitations that are to be included in the state space. state : list of integers The state in the number basis representation. ket : Qobj A Qobj instance that represent a Fock state in the exication-number- restricted state space defined by dims and exciations.

### Quantum Operators¶

This module contains functions for generating Qobj representation of a variety of commonly occuring quantum operators.

create(N, offset=0)[source]

Creation (raising) operator.

Parameters: N : int Dimension of Hilbert space. oper : qobj Qobj for raising operator. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator.

Examples

>>> create(4)
Quantum object: dims = [, ], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
[ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
[ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
[ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]

destroy(N, offset=0)[source]

Destruction (lowering) operator.

Parameters: N : int Dimension of Hilbert space. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator. oper : qobj Qobj for lowering operator.

Examples

>>> destroy(4)
Quantum object: dims = [, ], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
[ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]

displace(N, alpha, offset=0)[source]

Single-mode displacement operator.

Parameters: N : int Dimension of Hilbert space. alpha : float/complex Displacement amplitude. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator. oper : qobj Displacement operator.

Examples

>>> displace(4,0.25)
Quantum object: dims = [, ], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
[ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
[ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
[ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]

jmat(j, *args)[source]

Higher-order spin operators:

Parameters: j : float Spin of operator args : str Which operator to return ‘x’,’y’,’z’,’+’,’-‘. If no args given, then output is [‘x’,’y’,’z’] jmat : qobj/list qobj for requested spin operator(s).

Notes

If no ‘args’ input, then returns array of [‘x’,’y’,’z’] operators.

Examples

>>> jmat(1)
[ Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.          0.70710678  0.        ]
[ 0.70710678  0.          0.70710678]
[ 0.          0.70710678  0.        ]]
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j          0.+0.70710678j  0.+0.j        ]
[ 0.-0.70710678j  0.+0.j          0.+0.70710678j]
[ 0.+0.j          0.-0.70710678j  0.+0.j        ]]
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 1.  0.  0.]
[ 0.  0.  0.]
[ 0.  0. -1.]]]

num(N, offset=0)[source]

Quantum object for number operator.

Parameters: N : int The dimension of the Hilbert space. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator. oper: qobj Qobj for number operator.

Examples

>>> num(4)
Quantum object: dims = [, ], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[0 0 0 0]
[0 1 0 0]
[0 0 2 0]
[0 0 0 3]]

qeye(N)[source]

Identity operator

Parameters: N : int or list of ints Dimension of Hilbert space. If provided as a list of ints, then the dimension is the product over this list, but the dims property of the new Qobj are set to this list. oper : qobj Identity operator Qobj.

Examples

>>> qeye(3)
Quantum object: dims = [, ], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 1.  0.  0.]
[ 0.  1.  0.]
[ 0.  0.  1.]]

identity(N)[source]

Identity operator. Alternative name to qeye.

Parameters: N : int or list of ints Dimension of Hilbert space. If provided as a list of ints, then the dimension is the product over this list, but the dims property of the new Qobj are set to this list. oper : qobj Identity operator Qobj.
qutrit_ops()[source]

Operators for a three level system (qutrit).

Returns: opers: array array of qutrit operators.
sigmam()[source]

Annihilation operator for Pauli spins.

Examples

>>> sigmam()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  0.]
[ 1.  0.]]

sigmap()[source]

Creation operator for Pauli spins.

Examples

>>> sigmam()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  1.]
[ 0.  0.]]

sigmax()[source]

Pauli spin 1/2 sigma-x operator

Examples

>>> sigmax()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  1.]
[ 1.  0.]]

sigmay()[source]

Pauli spin 1/2 sigma-y operator.

Examples

>>> sigmay()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.-1.j]
[ 0.+1.j  0.+0.j]]

sigmaz()[source]

Pauli spin 1/2 sigma-z operator.

Examples

>>> sigmaz()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 1.  0.]
[ 0. -1.]]

squeeze(N, z, offset=0)[source]

Single-mode Squeezing operator.

Parameters: N : int Dimension of hilbert space. z : float/complex Squeezing parameter. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator. oper : qutip.qobj.Qobj Squeezing operator.

Examples

>>> squeeze(4, 0.25)
Quantum object: dims = [, ], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
[ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
[-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
[ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]

squeezing(a1, a2, z)[source]

Generalized squeezing operator.

$S(z) = \exp\left(\frac{1}{2}\left(z^*a_1a_2 - za_1^\dagger a_2^\dagger\right)\right)$
Parameters: a1 : qutip.qobj.Qobj Operator 1. a2 : qutip.qobj.Qobj Operator 2. z : float/complex Squeezing parameter. oper : qutip.qobj.Qobj Squeezing operator.
phase(N, phi0=0)[source]

Single-mode Pegg-Barnett phase operator.

Parameters: N : int Number of basis states in Hilbert space. phi0 : float Reference phase. oper : qobj Phase operator with respect to reference phase.

Notes

The Pegg-Barnett phase operator is Hermitian on a truncated Hilbert space.

enr_destroy(dims, excitations)[source]

Generate annilation operators for modes in a excitation-number-restricted state space. For example, consider a system consisting of 4 modes, each with 5 states. The total hilbert space size is 5**4 = 625. If we are only interested in states that contain up to 2 excitations, we only need to include states such as

(0, 0, 0, 0) (0, 0, 0, 1) (0, 0, 0, 2) (0, 0, 1, 0) (0, 0, 1, 1) (0, 0, 2, 0) ...

This function creates annihilation operators for the 4 modes that act within this state space:

a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)

From this point onwards, the annihiltion operators a1, ..., a4 can be used to setup a Hamiltonian, collapse operators and expectation-value operators, etc., following the usual pattern.

Parameters: dims : list A list of the dimensions of each subsystem of a composite quantum system. excitations : integer The maximum number of excitations that are to be included in the state space. a_ops : list of qobj A list of annihilation operators for each mode in the composite quantum system described by dims.
enr_identity(dims, excitations)[source]

Generate the identity operator for the excitation-number restricted state space defined by the dims and exciations arguments. See the docstring for enr_fock for a more detailed description of these arguments.

Parameters: dims : list A list of the dimensions of each subsystem of a composite quantum system. excitations : integer The maximum number of excitations that are to be included in the state space. state : list of integers The state in the number basis representation. op : Qobj A Qobj instance that represent the identity operator in the exication-number-restricted state space defined by dims and exciations.

### Random Operators and States¶

This module is a collection of random state and operator generators. The sparsity of the ouput Qobj’s is controlled by varing the density parameter.

rand_dm(N, density=0.75, pure=False, dims=None)[source]

Creates a random NxN density matrix.

Parameters: N : int Shape of output density matrix. density : float Density between [0,1] of output density matrix. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]]. oper : qobj NxN density matrix quantum operator.

Notes

For small density matrices., choosing a low density will result in an error as no diagonal elements will be generated such that $$Tr(\rho)=1$$.

rand_herm(N, density=0.75, dims=None)[source]

Creates a random NxN sparse Hermitian quantum object.

Uses $$H=X+X^{+}$$ where $$X$$ is a randomly generated quantum operator with a given density.

Parameters: N : int Shape of output quantum operator. density : float Density between [0,1] of output Hermitian operator. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]]. oper : qobj NxN Hermitian quantum operator.
rand_ket(N, density=1, dims=None)[source]

Creates a random Nx1 sparse ket vector.

Parameters: N : int Number of rows for output quantum operator. density : float Density between [0,1] of output ket state. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],]. oper : qobj Nx1 ket state quantum operator.
rand_unitary(N, density=0.75, dims=None)[source]

Creates a random NxN sparse unitary quantum object.

Uses $$\exp(-iH)$$ where H is a randomly generated Hermitian operator.

Parameters: N : int Shape of output quantum operator. density : float Density between [0,1] of output Unitary operator. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]]. oper : qobj NxN Unitary quantum operator.

### Three-Level Atoms¶

This module provides functions that are useful for simulating the three level atom with QuTiP. A three level atom (qutrit) has three states, which are linked by dipole transitions so that 1 <-> 2 <-> 3. Depending on there relative energies they are in the ladder, lambda or vee configuration. The structure of the relevant operators is the same for any of the three configurations:

Ladder:          Lambda:                 Vee:
|two>                       |three>
-------|three>           -------                      -------
|                       / \             |one>         /
|                      /   \           -------       /
|                     /     \             \         /
-------|two>            /       \             \       /
|                   /         \             \     /
|                  /           \             \   /
|                 /        --------           \ /
-------|one>      -------      |three>         -------
|one>                       |two>


## Functions acting on states and operators¶

### Tensor¶

Module for the creation of composite quantum objects via the tensor product.

tensor(*args)[source]

Calculates the tensor product of input operators.

Parameters: args : array_like list or array of quantum objects for tensor product. obj : qobj A composite quantum object.

Examples

>>> tensor([sigmax(), sigmax()])
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]

super_tensor(*args)[source]

Calculates the tensor product of input superoperators, by tensoring together the underlying Hilbert spaces on which each vectorized operator acts.

Parameters: args : array_like list or array of quantum objects with type="super". obj : qobj A composite quantum object.
composite(*args)[source]

Given two or more operators, kets or bras, returns the Qobj corresponding to a composite system over each argument. For ordinary operators and vectors, this is the tensor product, while for superoperators and vectorized operators, this is the column-reshuffled tensor product.

If a mix of Qobjs supported on Hilbert and Liouville spaces are passed in, the former are promoted. Ordinary operators are assumed to be unitaries, and are promoted using to_super, while kets and bras are promoted by taking their projectors and using operator_to_vector(ket2dm(arg)).

tensor_contract(qobj, *pairs)[source]

Contracts a qobj along one or more index pairs. Note that this uses dense representations and thus should not be used for very large Qobjs.

Parameters: pairs : tuple One or more tuples (i, j) indicating that the i and j dimensions of the original qobj should be contracted. cqobj : Qobj The original Qobj with all named index pairs contracted away.

### Expectation Values¶

expect(oper, state)[source]

Calculates the expectation value for operator(s) and state(s).

Parameters: oper : qobj/array-like A single or a list or operators for expectation value. state : qobj/array-like A single or a list of quantum states or density matrices. expt : float/complex/array-like Expectation value. real if oper is Hermitian, complex otherwise. A (nested) array of expectaction values of state or operator are arrays.

Examples

>>> expect(num(4), basis(4, 3))
3

variance(oper, state)[source]

Variance of an operator for the given state vector or density matrix.

Parameters: oper : qobj Operator for expectation value. state : qobj/list A single or list of quantum states or density matrices.. var : float Variance of operator ‘oper’ for given state.

### Partial Transpose¶

Return the partial transpose of a Qobj instance rho, where mask is an array/list with length that equals the number of components of rho (that is, the length of rho.dims), and the values in mask indicates whether or not the corresponding subsystem is to be transposed. The elements in mask can be boolean or integers 0 or 1, where True/1 indicates that the corresponding subsystem should be tranposed.

Parameters: rho : qutip.qobj A density matrix. mask : list / array A mask that selects which subsystems should be transposed. method : str choice of method, dense or sparse. The default method is dense. The sparse implementation can be faster for large and sparse systems (hundreds of quantum states). rho_pr: qutip.qobj A density matrix with the selected subsystems transposed.

### Entropy Functions¶

concurrence(rho)[source]

Calculate the concurrence entanglement measure for a two-qubit state.

Parameters: state : qobj Ket, bra, or density matrix for a two-qubit state. concur : float Concurrence

References

entropy_conditional(rho, selB, base=2.718281828459045, sparse=False)[source]

Calculates the conditional entropy $$S(A|B)=S(A,B)-S(B)$$ of a slected density matrix component.

Parameters: rho : qobj Density matrix of composite object selB : int/list Selected components for density matrix B base : {e,2} Base of logarithm. sparse : {False,True} Use sparse eigensolver. ent_cond : float Value of conditional entropy
entropy_linear(rho)[source]

Linear entropy of a density matrix.

Parameters: rho : qobj sensity matrix or ket/bra vector. entropy : float Linear entropy of rho.

Examples

>>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
>>> entropy_linear(rho)
0.5

entropy_mutual(rho, selA, selB, base=2.718281828459045, sparse=False)[source]

Calculates the mutual information S(A:B) between selection components of a system density matrix.

Parameters: rho : qobj Density matrix for composite quantum systems selA : int/list int or list of first selected density matrix components. selB : int/list int or list of second selected density matrix components. base : {e,2} Base of logarithm. sparse : {False,True} Use sparse eigensolver. ent_mut : float Mutual information between selected components.
entropy_vn(rho, base=2.718281828459045, sparse=False)[source]

Von-Neumann entropy of density matrix

Parameters: rho : qobj Density matrix. base : {e,2} Base of logarithm. sparse : {False,True} Use sparse eigensolver. entropy : float Von-Neumann entropy of rho.

Examples

>>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
>>> entropy_vn(rho,2)
1.0


### Density Matrix Metrics¶

This module contains a collection of functions for calculating metrics (distance measures) between states and operators.

fidelity(A, B)[source]

Calculates the fidelity (pseudo-metric) between two density matrices. See: Nielsen & Chuang, “Quantum Computation and Quantum Information”

Parameters: A : qobj Density matrix or state vector. B : qobj Density matrix or state vector with same dimensions as A. fid : float Fidelity pseudo-metric between A and B.

Examples

>>> x = fock_dm(5,3)
>>> y = coherent_dm(5,1)
>>> fidelity(x,y)
0.24104350624628332

tracedist(A, B, sparse=False, tol=0)[source]

Calculates the trace distance between two density matrices.. See: Nielsen & Chuang, “Quantum Computation and Quantum Information”

Parameters: A : qobj Density matrix or state vector. B : qobj Density matrix or state vector with same dimensions as A. tol : float Tolerance used by sparse eigensolver, if used. (0=Machine precision) sparse : {False, True} Use sparse eigensolver. tracedist : float Trace distance between A and B.

Examples

>>> x=fock_dm(5,3)
>>> y=coherent_dm(5,1)
>>> tracedist(x,y)
0.9705143161472971

bures_dist(A, B)[source]

Returns the Bures distance between two density matrices A & B.

The Bures distance ranges from 0, for states with unit fidelity, to sqrt(2).

Parameters: A : qobj Density matrix or state vector. B : qobj Density matrix or state vector with same dimensions as A. dist : float Bures distance between density matrices.
bures_angle(A, B)[source]

Returns the Bures Angle between two density matrices A & B.

The Bures angle ranges from 0, for states with unit fidelity, to pi/2.

Parameters: A : qobj Density matrix or state vector. B : qobj Density matrix or state vector with same dimensions as A. angle : float Bures angle between density matrices.
hilbert_dist(A, B)[source]

Returns the Hilbert-Schmidt distance between two density matrices A & B.

Parameters: A : qobj Density matrix or state vector. B : qobj Density matrix or state vector with same dimensions as A. dist : float Hilbert-Schmidt distance between density matrices.

Notes

See V. Vedral and M. B. Plenio, Phys. Rev. A 57, 1619 (1998).

average_gate_fidelity(oper)[source]

Given a Qobj representing the supermatrix form of a map, returns the average gate fidelity (pseudo-metric) of that map.

Parameters: A : Qobj Quantum object representing a superoperator. fid : float Fidelity pseudo-metric between A and the identity superoperator.
process_fidelity(U1, U2, normalize=True)[source]

Calculate the process fidelity given two process operators.

### Continous Variables¶

This module contains a collection functions for calculating continuous variable quantities from fock-basis representation of the state of multi-mode fields.

correlation_matrix(basis, rho=None)[source]

Given a basis set of operators $$\{a\}_n$$, calculate the correlation matrix:

$C_{mn} = \langle a_m a_n \rangle$
Parameters: basis : list of qutip.qobj.Qobj List of operators that defines the basis for the correlation matrix. rho : qutip.qobj.Qobj Density matrix for which to calculate the correlation matrix. If rho is None, then a matrix of correlation matrix operators is returned instead of expectation values of those operators. corr_mat: array A 2-dimensional array of correlation values or operators.
covariance_matrix(basis, rho, symmetrized=True)[source]

Given a basis set of operators $$\{a\}_n$$, calculate the covariance matrix:

$V_{mn} = \frac{1}{2}\langle a_m a_n + a_n a_m \rangle - \langle a_m \rangle \langle a_n\rangle$

or, if of the optional argument symmetrized=False,

$V_{mn} = \langle a_m a_n\rangle - \langle a_m \rangle \langle a_n\rangle$
Parameters: basis : list of qutip.qobj.Qobj List of operators that defines the basis for the covariance matrix. rho : qutip.qobj.Qobj Density matrix for which to calculate the covariance matrix. symmetrized : bool Flag indicating whether the symmetrized (default) or non-symmetrized correlation matrix is to be calculated. corr_mat: array A 2-dimensional array of covariance values.
correlation_matrix_field(a1, a2, rho=None)[source]

Calculate the correlation matrix for given field operators $$a_1$$ and $$a_2$$. If a density matrix is given the expectation values are calculated, otherwise a matrix with operators is returned.

Parameters: a1 : qutip.qobj.Qobj Field operator for mode 1. a2 : qutip.qobj.Qobj Field operator for mode 2. rho : qutip.qobj.Qobj Density matrix for which to calculate the covariance matrix. cov_mat: array of complex numbers or qutip.qobj.Qobj A 2-dimensional array of covariance values, or, if rho=0, a matrix of operators.

Calculate the quadrature correlation matrix with given field operators $$a_1$$ and $$a_2$$. If a density matrix is given the expectation values are calculated, otherwise a matrix with operators is returned.

Parameters: a1 : qutip.qobj.Qobj Field operator for mode 1. a2 : qutip.qobj.Qobj Field operator for mode 2. rho : qutip.qobj.Qobj Density matrix for which to calculate the covariance matrix. corr_mat: array of complex numbers or qutip.qobj.Qobj A 2-dimensional array of covariance values for the field quadratures, or, if rho=0, a matrix of operators.
wigner_covariance_matrix(a1=None, a2=None, R=None, rho=None)[source]

Calculate the Wigner covariance matrix $$V_{ij} = \frac{1}{2}(R_{ij} + R_{ji})$$, given the quadrature correlation matrix $$R_{ij} = \langle R_{i} R_{j}\rangle - \langle R_{i}\rangle \langle R_{j}\rangle$$, where $$R = (q_1, p_1, q_2, p_2)^T$$ is the vector with quadrature operators for the two modes.

Alternatively, if R = None, and if annihilation operators a1 and a2 for the two modes are supplied instead, the quadrature correlation matrix is constructed from the annihilation operators before then the covariance matrix is calculated.

Parameters: a1 : qutip.qobj.Qobj Field operator for mode 1. a2 : qutip.qobj.Qobj Field operator for mode 2. R : array The quadrature correlation matrix. rho : qutip.qobj.Qobj Density matrix for which to calculate the covariance matrix. cov_mat: array A 2-dimensional array of covariance values.
logarithmic_negativity(V)[source]

Calculate the logarithmic negativity given the symmetrized covariance matrix, see qutip.continous_variables.covariance_matrix. Note that the two-mode field state that is described by V must be Gaussian for this function to applicable.

Parameters: V : 2d array The covariance matrix. N: float, the logarithmic negativity for the two-mode Gaussian state that is described by the the Wigner covariance matrix V.

## Dynamics and Time-Evolution¶

### Schrödinger Equation¶

This module provides solvers for the unitary Schrodinger equation.

sesolve(H, rho0, tlist, e_ops, args={}, options=None, progress_bar=<qutip.ui.progressbar.BaseProgressBar object at 0x105876c90>)[source]

Schrodinger equation evolution of a state vector for a given Hamiltonian.

Evolve the state vector or density matrix (rho0) using a given Hamiltonian (H), by integrating the set of ordinary differential equations that define the system.

The output is either the state vector at arbitrary points in time (tlist), or the expectation values of the supplied operators (e_ops). If e_ops is a callback function, it is invoked for each time in tlist with time and the state as arguments, and the function does not use any return values.

Parameters: H : qutip.qobj system Hamiltonian, or a callback function for time-dependent Hamiltonians. rho0 : qutip.qobj initial density matrix or state vector (ket). tlist : list / array list of times for $$t$$. e_ops : list of qutip.qobj / callback function single single operator or list of operators for which to evaluate expectation values. args : dictionary dictionary of parameters for time-dependent Hamiltonians and collapse operators. options : qutip.Qdeoptions with options for the ODE solver. output: qutip.solver An instance of the class qutip.solver, which contains either an array of expectation values for the times specified by tlist, or an array or state vectors or density matrices corresponding to the times in tlist [if e_ops is an empty list], or nothing if a callback function was given inplace of operators for which to calculate the expectation values.

### Master Equation¶

This module provides solvers for the Lindblad master equation and von Neumann equation.

mesolve(H, rho0, tlist, c_ops, e_ops, args={}, options=None, progress_bar=None)[source]

Master equation evolution of a density matrix for a given Hamiltonian and set of collapse operators, or a Liouvillian.

Evolve the state vector or density matrix (rho0) using a given Hamiltonian (H) and an [optional] set of collapse operators (c_ops), by integrating the set of ordinary differential equations that define the system. In the absence of collapse operators the system is evolved according to the unitary evolution of the Hamiltonian.

The output is either the state vector at arbitrary points in time (tlist), or the expectation values of the supplied operators (e_ops). If e_ops is a callback function, it is invoked for each time in tlist with time and the state as arguments, and the function does not use any return values.

If either H or the Qobj elements in c_ops are superoperators, they will be treated as direct contributions to the total system Liouvillian. This allows to solve master equations that are not on standard Lindblad form by passing a custom Liouvillian in place of either the H or c_ops elements.

Time-dependent operators

For time-dependent problems, H and c_ops can be callback functions that takes two arguments, time and args, and returns the Hamiltonian or Liouvillian for the system at that point in time (callback format).

Alternatively, H and c_ops can be a specified in a nested-list format where each element in the list is a list of length 2, containing an operator (qutip.qobj) at the first element and where the second element is either a string (list string format), a callback function (list callback format) that evaluates to the time-dependent coefficient for the corresponding operator, or a NumPy array (list array format) which specifies the value of the coefficient to the corresponding operator for each value of t in tlist.

Examples

H = [[H0, ‘sin(w*t)’], [H1, ‘sin(2*w*t)’]]

H = [[H0, f0_t], [H1, f1_t]]

where f0_t and f1_t are python functions with signature f_t(t, args).

H = [[H0, np.sin(w*tlist)], [H1, np.sin(2*w*tlist)]]

In the list string format and list callback format, the string expression and the callback function must evaluate to a real or complex number (coefficient for the corresponding operator).

In all cases of time-dependent operators, args is a dictionary of parameters that is used when evaluating operators. It is passed to the callback functions as second argument.

Additional options to mesolve can be set via the options argument, which should be an instance of qutip.solver.Options. Many ODE integration options can be set this way, and the store_states and store_final_state options can be used to store states even though expectation values are requested via the e_ops argument.

Note

If an element in the list-specification of the Hamiltonian or the list of collapse operators are in superoperator form it will be added to the total Liouvillian of the problem with out further transformation. This allows for using mesolve for solving master equations that are not on standard Lindblad form.

Note

On using callback function: mesolve transforms all qutip.qobj objects to sparse matrices before handing the problem to the integrator function. In order for your callback function to work correctly, pass all qutip.qobj objects that are used in constructing the Hamiltonian via args. mesolve will check for qutip.qobj in args and handle the conversion to sparse matrices. All other qutip.qobj objects that are not passed via args will be passed on to the integrator in scipy which will raise an NotImplemented exception.

Parameters: System Hamiltonian, or a callback function for time-dependent Hamiltonians, or alternatively a system Liouvillian. rho0 : qutip.Qobj initial density matrix or state vector (ket). tlist : list / array list of times for $$t$$. c_ops : list of qutip.Qobj single collapse operator, or list of collapse operators, or a list of Liouvillian superoperators. e_ops : list of qutip.Qobj / callback function single single operator or list of operators for which to evaluate expectation values. args : dictionary dictionary of parameters for time-dependent Hamiltonians and collapse operators. options : qutip.Options with options for the solver. progress_bar: BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation. result: qutip.Result An instance of the class qutip.Result, which contains either an array result.expect of expectation values for the times specified by tlist, or an array result.states of state vectors or density matrices corresponding to the times in tlist [if e_ops is an empty list], or nothing if a callback function was given in place of operators for which to calculate the expectation values.

### Monte Carlo Evolution¶

mcsolve(H, psi0, tlist, c_ops, e_ops, ntraj=None, args={}, options=None, progress_bar=True, map_func=None, map_kwargs=None)[source]

Monte Carlo evolution of a state vector $$|\psi \rangle$$ for a given Hamiltonian and sets of collapse operators, and possibly, operators for calculating expectation values. Options for the underlying ODE solver are given by the Options class.

mcsolve supports time-dependent Hamiltonians and collapse operators using either Python functions of strings to represent time-dependent coefficients. Note that, the system Hamiltonian MUST have at least one constant term.

As an example of a time-dependent problem, consider a Hamiltonian with two terms H0 and H1, where H1 is time-dependent with coefficient sin(w*t), and collapse operators C0 and C1, where C1 is time-dependent with coeffcient exp(-a*t). Here, w and a are constant arguments with values W and A.

Using the Python function time-dependent format requires two Python functions, one for each collapse coefficient. Therefore, this problem could be expressed as:

def H1_coeff(t,args):
return sin(args['w']*t)

def C1_coeff(t,args):
return exp(-args['a']*t)

H = [H0, [H1, H1_coeff]]

c_ops = [C0, [C1, C1_coeff]]

args={'a': A, 'w': W}


or in String (Cython) format we could write:

H = [H0, [H1, 'sin(w*t)']]

c_ops = [C0, [C1, 'exp(-a*t)']]

args={'a': A, 'w': W}


Constant terms are preferably placed first in the Hamiltonian and collapse operator lists.

Parameters: System Hamiltonian. psi0 : qutip.Qobj Initial state vector tlist : array_like Times at which results are recorded. ntraj : int Number of trajectories to run. c_ops : array_like single collapse operator or list or array of collapse operators. e_ops : array_like single operator or list or array of operators for calculating expectation values. args : dict Arguments for time-dependent Hamiltonian and collapse operator terms. options : Options Instance of ODE solver options. progress_bar: BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation. Set to None to disable the progress bar. map_func: function A map function for managing the calls to the single-trajactory solver. map_kwargs: dictionary Optional keyword arguments to the map_func function. results : qutip.solver.Result Object storing all results from the simulation. Note It is possible to reuse the random number seeds from a previous run of the mcsolver by passing the output Result object seeds via the Options class, i.e. Options(seeds=prev_result.seeds).
mcsolve_f90(H, psi0, tlist, c_ops, e_ops, ntraj=None, options=<qutip.solver.Options instance at 0x1048d6b48>, sparse_dms=True, serial=False, ptrace_sel=[], calc_entropy=False)[source]

Monte-Carlo wave function solver with fortran 90 backend. Usage is identical to qutip.mcsolve, for problems without explicit time-dependence, and with some optional input:

Parameters: H : qobj System Hamiltonian. psi0 : qobj Initial state vector tlist : array_like Times at which results are recorded. ntraj : int Number of trajectories to run. c_ops : array_like list or array of collapse operators. e_ops : array_like list or array of operators for calculating expectation values. options : Options Instance of solver options. sparse_dms : boolean If averaged density matrices are returned, they will be stored as sparse (Compressed Row Format) matrices during computation if sparse_dms = True (default), and dense matrices otherwise. Dense matrices might be preferable for smaller systems. serial : boolean If True (default is False) the solver will not make use of the multiprocessing module, and simply run in serial. ptrace_sel: list This optional argument specifies a list of components to keep when returning a partially traced density matrix. This can be convenient for large systems where memory becomes a problem, but you are only interested in parts of the density matrix. calc_entropy : boolean If ptrace_sel is specified, calc_entropy=True will have the solver return the averaged entropy over trajectories in results.entropy. This can be interpreted as a measure of entanglement. See Phys. Rev. Lett. 93, 120408 (2004), Phys. Rev. A 86, 022310 (2012). results : Result Object storing all results from simulation.

### Exponential Series¶

essolve(H, rho0, tlist, c_op_list, e_ops)[source]

Evolution of a state vector or density matrix (rho0) for a given Hamiltonian (H) and set of collapse operators (c_op_list), by expressing the ODE as an exponential series. The output is either the state vector at arbitrary points in time (tlist), or the expectation values of the supplied operators (e_ops).

Parameters: H : qobj/function_type System Hamiltonian. rho0 : qutip.qobj Initial state density matrix. tlist : list/array list of times for $$t$$. c_op_list : list of qutip.qobj list of qutip.qobj collapse operators. e_ops : list of qutip.qobj list of qutip.qobj operators for which to evaluate expectation values. expt_array : array Expectation values of wavefunctions/density matrices for the times specified in tlist. Note This solver does not support time-dependent Hamiltonians.
ode2es(L, rho0)[source]

Creates an exponential series that describes the time evolution for the initial density matrix (or state vector) rho0, given the Liouvillian (or Hamiltonian) L.

Parameters: L : qobj Liouvillian of the system. rho0 : qobj Initial state vector or density matrix. eseries : qutip.eseries eseries represention of the system dynamics.

### Bloch-Redfield Master Equation¶

brmesolve(H, psi0, tlist, a_ops, e_ops=[], spectra_cb=[], c_ops=None, args={}, options=<qutip.solver.Options instance at 0x105963320>)[source]

Solve the dynamics for a system using the Bloch-Redfield master equation.

Note

This solver does not currently support time-dependent Hamiltonians.

Parameters: System Hamiltonian. rho0 / psi0: :class:qutip.Qobj Initial density matrix or state vector (ket). tlist : list / array List of times for $$t$$. a_ops : list of qutip.qobj List of system operators that couple to bath degrees of freedom. e_ops : list of qutip.qobj / callback function List of operators for which to evaluate expectation values. c_ops : list of qutip.qobj List of system collapse operators. args : dictionary Placeholder for future implementation, kept for API consistency. options : qutip.solver.Options Options for the solver. result: qutip.solver.Result An instance of the class qutip.solver.Result, which contains either an array of expectation values, for operators given in e_ops, or a list of states for the times specified by tlist.
bloch_redfield_tensor(H, a_ops, spectra_cb, c_ops=None, use_secular=True)[source]

Calculate the Bloch-Redfield tensor for a system given a set of operators and corresponding spectral functions that describes the system’s coupling to its environment.

Note

This tensor generation requires a time-independent Hamiltonian.

Parameters: H : qutip.qobj System Hamiltonian. a_ops : list of qutip.qobj List of system operators that couple to the environment. spectra_cb : list of callback functions List of callback functions that evaluate the noise power spectrum at a given frequency. c_ops : list of qutip.qobj List of system collapse operators. use_secular : bool Flag (True of False) that indicates if the secular approximation should be used. R, kets: qutip.Qobj, list of qutip.Qobj R is the Bloch-Redfield tensor and kets is a list eigenstates of the Hamiltonian.
bloch_redfield_solve(R, ekets, rho0, tlist, e_ops=[], options=None)[source]

Evolve the ODEs defined by Bloch-Redfield master equation. The Bloch-Redfield tensor can be calculated by the function bloch_redfield_tensor.

Parameters: R : qutip.qobj Bloch-Redfield tensor. ekets : array of qutip.qobj Array of kets that make up a basis tranformation for the eigenbasis. rho0 : qutip.qobj Initial density matrix. tlist : list / array List of times for $$t$$. e_ops : list of qutip.qobj / callback function List of operators for which to evaluate expectation values. options : qutip.Qdeoptions Options for the ODE solver. output: qutip.solver An instance of the class qutip.solver, which contains either an array of expectation values for the times specified by tlist.

### Floquet States and Floquet-Markov Master Equation¶

fmmesolve(H, rho0, tlist, c_ops, e_ops=[], spectra_cb=[], T=None, args={}, options=<qutip.solver.Options instance at 0x105963290>, floquet_basis=True, kmax=5)[source]

Solve the dynamics for the system using the Floquet-Markov master equation.

Note

This solver currently does not support multiple collapse operators.

Parameters: H : qutip.qobj system Hamiltonian. rho0 / psi0 : qutip.qobj initial density matrix or state vector (ket). tlist : list / array list of times for $$t$$. c_ops : list of qutip.qobj list of collapse operators. e_ops : list of qutip.qobj / callback function list of operators for which to evaluate expectation values. spectra_cb : list callback functions List of callback functions that compute the noise power spectrum as a function of frequency for the collapse operators in c_ops. T : float The period of the time-dependence of the hamiltonian. The default value ‘None’ indicates that the ‘tlist’ spans a single period of the driving. args : dictionary dictionary of parameters for time-dependent Hamiltonians and collapse operators. This dictionary should also contain an entry ‘w_th’, which is the temperature of the environment (if finite) in the energy/frequency units of the Hamiltonian. For example, if the Hamiltonian written in units of 2pi GHz, and the temperature is given in K, use the following conversion >>> temperature = 25e-3 # unit K >>> h = 6.626e-34 >>> kB = 1.38e-23 >>> args['w_th'] = temperature * (kB / h) * 2 * pi * 1e-9  options : qutip.solver options for the ODE solver. k_max : int The truncation of the number of sidebands (default 5). output : qutip.solver An instance of the class qutip.solver, which contains either an array of expectation values for the times specified by tlist.
floquet_modes(H, T, args=None, sort=False, U=None)[source]

Calculate the initial Floquet modes Phi_alpha(0) for a driven system with period T.

Returns a list of qutip.qobj instances representing the Floquet modes and a list of corresponding quasienergies, sorted by increasing quasienergy in the interval [-pi/T, pi/T]. The optional parameter sort decides if the output is to be sorted in increasing quasienergies or not.

Parameters: H : qutip.qobj system Hamiltonian, time-dependent with period T args : dictionary dictionary with variables required to evaluate H T : float The period of the time-dependence of the hamiltonian. The default value ‘None’ indicates that the ‘tlist’ spans a single period of the driving. U : qutip.qobj The propagator for the time-dependent Hamiltonian with period T. If U is None (default), it will be calculated from the Hamiltonian H using qutip.propagator.propagator. output : list of kets, list of quasi energies Two lists: the Floquet modes as kets and the quasi energies.
floquet_modes_t(f_modes_0, f_energies, t, H, T, args=None)[source]

Calculate the Floquet modes at times tlist Phi_alpha(tlist) propagting the initial Floquet modes Phi_alpha(0)

Parameters: f_modes_0 : list of qutip.qobj (kets) Floquet modes at $$t$$ f_energies : list Floquet energies. t : float The time at which to evaluate the floquet modes. H : qutip.qobj system Hamiltonian, time-dependent with period T args : dictionary dictionary with variables required to evaluate H T : float The period of the time-dependence of the hamiltonian. output : list of kets The Floquet modes as kets at time $$t$$
floquet_modes_table(f_modes_0, f_energies, tlist, H, T, args=None)[source]

Pre-calculate the Floquet modes for a range of times spanning the floquet period. Can later be used as a table to look up the floquet modes for any time.

Parameters: f_modes_0 : list of qutip.qobj (kets) Floquet modes at $$t$$ f_energies : list Floquet energies. tlist : array The list of times at which to evaluate the floquet modes. H : qutip.qobj system Hamiltonian, time-dependent with period T T : float The period of the time-dependence of the hamiltonian. args : dictionary dictionary with variables required to evaluate H output : nested list A nested list of Floquet modes as kets for each time in tlist
floquet_modes_t_lookup(f_modes_table_t, t, T)[source]

Lookup the floquet mode at time t in the pre-calculated table of floquet modes in the first period of the time-dependence.

Parameters: f_modes_table_t : nested list of qutip.qobj (kets) A lookup-table of Floquet modes at times precalculated by qutip.floquet.floquet_modes_table. t : float The time for which to evaluate the Floquet modes. T : float The period of the time-dependence of the hamiltonian. output : nested list A list of Floquet modes as kets for the time that most closely matching the time t in the supplied table of Floquet modes.
floquet_states_t(f_modes_0, f_energies, t, H, T, args=None)[source]

Evaluate the floquet states at time t given the initial Floquet modes.

Parameters: f_modes_t : list of qutip.qobj (kets) A list of initial Floquet modes (for time $$t=0$$). f_energies : array The Floquet energies. t : float The time for which to evaluate the Floquet states. H : qutip.qobj System Hamiltonian, time-dependent with period T. T : float The period of the time-dependence of the hamiltonian. args : dictionary Dictionary with variables required to evaluate H. output : list A list of Floquet states for the time $$t$$.
floquet_wavefunction_t(f_modes_0, f_energies, f_coeff, t, H, T, args=None)[source]

Evaluate the wavefunction for a time t using the Floquet state decompositon, given the initial Floquet modes.

Parameters: f_modes_t : list of qutip.qobj (kets) A list of initial Floquet modes (for time $$t=0$$). f_energies : array The Floquet energies. f_coeff : array The coefficients for Floquet decomposition of the initial wavefunction. t : float The time for which to evaluate the Floquet states. H : qutip.qobj System Hamiltonian, time-dependent with period T. T : float The period of the time-dependence of the hamiltonian. args : dictionary Dictionary with variables required to evaluate H. output : qutip.qobj The wavefunction for the time $$t$$.
floquet_state_decomposition(f_states, f_energies, psi)[source]

Decompose the wavefunction psi (typically an initial state) in terms of the Floquet states, $$\psi = \sum_\alpha c_\alpha \psi_\alpha(0)$$.

Parameters: f_states : list of qutip.qobj (kets) A list of Floquet modes. f_energies : array The Floquet energies. psi : qutip.qobj The wavefunction to decompose in the Floquet state basis. output : array The coefficients $$c_\alpha$$ in the Floquet state decomposition.
fsesolve(H, psi0, tlist, e_ops=[], T=None, args={}, Tsteps=100)[source]

Solve the Schrodinger equation using the Floquet formalism.

Parameters: H : qutip.qobj.Qobj System Hamiltonian, time-dependent with period T. psi0 : qutip.qobj Initial state vector (ket). tlist : list / array list of times for $$t$$. e_ops : list of qutip.qobj / callback function list of operators for which to evaluate expectation values. If this list is empty, the state vectors for each time in tlist will be returned instead of expectation values. T : float The period of the time-dependence of the hamiltonian. args : dictionary Dictionary with variables required to evaluate H. Tsteps : integer The number of time steps in one driving period for which to precalculate the Floquet modes. Tsteps should be an even number. output : qutip.solver.Result An instance of the class qutip.solver.Result, which contains either an array of expectation values or an array of state vectors, for the times specified by tlist.

### Stochastic Schrödinger Equation and Master Equation¶

This module contains functions for solving stochastic schrodinger and master equations. The API should not be considered stable, and is subject to change when we work more on optimizing this module for performance and features.

smesolve(H, rho0, times, c_ops, sc_ops, e_ops, **kwargs)[source]

Solve stochastic master equation. Dispatch to specific solvers depending on the value of the solver keyword argument.

Parameters: System Hamiltonian. rho0 : qutip.Qobj Initial density matrix or state vector (ket). times : list / array List of times for $$t$$. Must be uniformly spaced. c_ops : list of qutip.Qobj Deterministic collapse operator which will contribute with a standard Lindblad type of dissipation. sc_ops : list of qutip.Qobj List of stochastic collapse operators. Each stochastic collapse operator will give a deterministic and stochastic contribution to the eqaution of motion according to how the d1 and d2 functions are defined. e_ops : list of qutip.Qobj / callback function single single operator or list of operators for which to evaluate expectation values. kwargs : dictionary Optional keyword arguments. See qutip.stochastic.StochasticSolverOptions. output: qutip.solver.SolverResult An instance of the class qutip.solver.SolverResult.
ssesolve(H, psi0, times, sc_ops, e_ops, **kwargs)[source]

Solve the stochastic Schrödinger equation. Dispatch to specific solvers depending on the value of the solver keyword argument.

Parameters: System Hamiltonian. psi0 : qutip.Qobj Initial state vector (ket). times : list / array List of times for $$t$$. Must be uniformly spaced. 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. kwargs : dictionary Optional keyword arguments. See qutip.stochastic.StochasticSolverOptions. output: qutip.solver.SolverResult An instance of the class qutip.solver.SolverResult.
smepdpsolve(H, rho0, times, c_ops, e_ops, **kwargs)[source]

A stochastic (piecewse deterministic process) PDP solver for density matrix evolution.

Parameters: System Hamiltonian. rho0 : qutip.Qobj Initial density matrix. times : list / array List of times for $$t$$. Must be uniformly spaced. c_ops : list of qutip.Qobj Deterministic collapse operator which will contribute with a standard Lindblad type of dissipation. sc_ops : list of qutip.Qobj List of stochastic collapse operators. Each stochastic collapse operator will give a deterministic and stochastic contribution to the eqaution of motion according to how the d1 and d2 functions are defined. e_ops : list of qutip.Qobj / callback function single single operator or list of operators for which to evaluate expectation values. kwargs : dictionary Optional keyword arguments. See qutip.stochastic.StochasticSolverOptions. output: qutip.solver.SolverResult An instance of the class qutip.solver.SolverResult.
ssepdpsolve(H, psi0, times, c_ops, e_ops, **kwargs)[source]

A stochastic (piecewse deterministic process) PDP solver for wavefunction evolution. For most purposes, use qutip.mcsolve instead for quantum trajectory simulations.

Parameters: System Hamiltonian. psi0 : qutip.Qobj Initial state vector (ket). times : list / array List of times for $$t$$. Must be uniformly spaced. c_ops : list of qutip.Qobj Deterministic collapse operator which will contribute with a standard Lindblad type of dissipation. e_ops : list of qutip.Qobj / callback function single single operator or list of operators for which to evaluate expectation values. kwargs : dictionary Optional keyword arguments. See qutip.stochastic.StochasticSolverOptions. output: qutip.solver.SolverResult An instance of the class qutip.solver.SolverResult.

### Correlation Functions¶

correlation(H, state0, tlist, taulist, c_ops, a_op, b_op, solver='me', reverse=False, args=None, options=<qutip.solver.Options instance at 0x105963a70>)[source]
Calculate the two-operator two-time correlation function: $$\left<A(t+\tau)B(t)\right>$$ along two time axes using the quantum regression theorem and the evolution solver indicated by the solver parameter.
Parameters: H : qutip.qobj.Qobj system Hamiltonian. state0 : qutip.qobj.Qobj Initial state density matrix $$\rho(t_0)$$ or state vector $$\psi(t_0)$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. tlist : list / array list of times for $$t$$. tlist must be positive and contain the element 0. When taking steady-steady correlations only one tlist value is necessary, i.e. :math:t ightarrow infty; here tlist is automatically set, ignoring user input. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. reverse : bool If True, calculate $$\left$$ instead of $$\left$$. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_mat: array An 2-dimensional array (matrix) of correlation values for the times specified by tlist (first index) and taulist (second index). If tlist is None, then a 1-dimensional array of correlation values is returned instead.
correlation_ss(H, taulist, c_ops, a_op, b_op, solver='me', reverse=False, args=None, options=<qutip.solver.Options instance at 0x105963a28>)[source]

Calculate the two-operator two-time correlation function:

$\begin{split}\lim_{t o \infty} \left<A(t+\tau)B(t)\right>\end{split}$

along one time axis (given steady-state initial conditions) using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Parameters: H : qutip.qobj.Qobj system Hamiltonian. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. reverse : bool If True, calculate $$\lim_{t o \infty} \left$$ instead of $$\lim_{t o \infty} \left$$. solver : str choice of solver (me for master-equation and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_vec: array An array of correlation values for the times specified by tlist.

References

See, Gardiner, Quantum Noise, Section 5.2.

correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op, solver='me', reverse=False, args=None, options=<qutip.solver.Options instance at 0x1059637e8>)[source]

Calculate the two-operator two-time correlation function: :math: left<A(t+tau)B(t)right> along one time axis using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Parameters: H : qutip.qobj.Qobj system Hamiltonian. state0 : qutip.qobj.Qobj Initial state density matrix $$\rho(t_0)$$ or state vector $$\psi(t_0)$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. reverse : bool If True, calculate $$\left$$ instead of $$\left$$. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_vec: array An array of correlation values for the times specified by tlist.

References

See, Gardiner, Quantum Noise, Section 5.2.

correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, solver='me', reverse=False, args=None, options=<qutip.solver.Options instance at 0x1059638c0>)[source]
Calculate the two-operator two-time correlation function: $$\left<A(t+\tau)B(t)\right>$$ along two time axes using the quantum regression theorem and the evolution solver indicated by the solver parameter.
Parameters: H : qutip.qobj.Qobj system Hamiltonian. state0 : qutip.qobj.Qobj Initial state density matrix $$\rho_0$$ or state vector $$\psi_0$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. tlist : list / array list of times for $$t$$. tlist must be positive and contain the element 0. When taking steady-steady correlations only one tlist value is necessary, i.e. :math:t ightarrow infty; here tlist is automatically set, ignoring user input. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. reverse : bool If True, calculate $$\left$$ instead of $$\left$$. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_mat: array An 2-dimensional array (matrix) of correlation values for the times specified by tlist (first index) and taulist (second index). If tlist is None, then a 1-dimensional array of correlation values is returned instead.
correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x105963908>)[source]

Calculate the three-operator two-time correlation function: $$\left<A(t)B(t+\tau)C(t)\right>$$ along one time axis using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Note: it is not possibly to calculate a physically meaningful correlation of this form where :math: tau<0.

Parameters: H : qutip.qobj.Qobj system Hamiltonian. rho0 : qutip.qobj.Qobj Initial state density matrix $$\rho(t_0)$$ or state vector $$\psi(t_0)$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. c_op : qutip.qobj.Qobj operator C. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_vec: array An array of correlation values for the times specified by taulist

References

See, Gardiner, Quantum Noise, Section 5.2.

correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x105963950>)[source]

Calculate the three-operator two-time correlation function: $$\left<A(t)B(t+\tau)C(t)\right>$$ along two time axes using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Note: it is not possibly to calculate a physically meaningful correlation of this form where :math: tau<0.

Parameters: H : qutip.qobj.Qobj system Hamiltonian, or a callback function for time-dependent Hamiltonians. rho0 : qutip.qobj.Qobj Initial state density matrix $$\rho_0$$ or state vector $$\psi_0$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. tlist : list / array list of times for $$t$$. tlist must be positive and contain the element 0. When taking steady-steady correlations only one tlist value is necessary, i.e. :math:t ightarrow infty; here tlist is automatically set, ignoring user input. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. (does not accept time dependence) a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. c_op : qutip.qobj.Qobj operator C. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_mat: array An 2-dimensional array (matrix) of correlation values for the times specified by tlist (first index) and taulist (second index). If tlist is None, then a 1-dimensional array of correlation values is returned instead.
correlation_4op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op, d_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x105963ab8>)[source]

Calculate the four-operator two-time correlation function: $$\left<A(t)B(t+\tau)C(t+\tau)D(t)\right>$$ along one time axis using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Note: it is not possibly to calculate a physically meaningful correlation of this form where $$\tau<0$$.

Parameters: H : qutip.qobj.Qobj system Hamiltonian. rho0 : qutip.qobj.Qobj Initial state density matrix $$\rho(t_0)$$ or state vector $$\psi(t_0)$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. c_op : qutip.qobj.Qobj operator C. d_op : qutip.qobj.Qobj operator D. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_vec: array An array of correlation values for the times specified by taulist

References

See, Gardiner, Quantum Noise, Section 5.2.

correlation_4op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op, d_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x105963b00>)[source]

Calculate the four-operator two-time correlation function: $$\left<A(t)B(t+\tau)C(t+\tau)D(t)\right>$$ along two time axes using the quantum regression theorem and the evolution solver indicated by the solver parameter.

Note: it is not possibly to calculate a physically meaningful correlation of this form where $$\tau<0$$.

Parameters: H : qutip.qobj.Qobj system Hamiltonian, or a callback function for time-dependent Hamiltonians. rho0 : qutip.qobj.Qobj Initial state density matrix $$\rho_0$$ or state vector $$\psi_0$$. If ‘state0’ is ‘None’, then the steady state will be used as the initial state. The ‘steady-state’ is only implemented for the me and es solvers. tlist : list / array list of times for $$t$$. tlist must be positive and contain the element 0. When taking steady-steady correlations only one tlist value is necessary, i.e. :math:t ightarrow infty; here tlist is automatically set, ignoring user input. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. (does not accept time dependence) a_op : qutip.qobj.Qobj operator A. b_op : qutip.qobj.Qobj operator B. c_op : qutip.qobj.Qobj operator C. d_op : qutip.qobj.Qobj operator D. solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. corr_mat: array An 2-dimensional array (matrix) of correlation values for the times specified by tlist (first index) and taulist (second index). If tlist is None, then a 1-dimensional array of correlation values is returned instead.
spectrum(H, wlist, c_ops, a_op, b_op, solver='es', use_pinv=False)[source]

Calculate the spectrum of the correlation function $$\lim_{t o \infty} \left<A(t+\tau)B(t)\right>$$, i.e., the Fourier transform of the correlation function:

$\begin{split}S(\omega) = \int_{-\infty}^{\infty} \lim_{t o \infty} \left<A(t+\tau)B(t)\right> e^{-i\omega\tau} d\tau.\end{split}$

using the solver indicated by the solver parameter. Note: this spectrum is only defined for stationary statistics (uses steady state rho0)

Parameters: H : qutip.qobj system Hamiltonian. wlist : list / array list of frequencies for $$\omega$$. c_ops : list of qutip.qobj list of collapse operators. a_op : qutip.qobj operator A. b_op : qutip.qobj operator B. solver : str choice of solver (es for exponential series and pi for psuedo-inverse) use_pinv : bool For use with the pi solver: if True use numpy’s pinv method, otherwise use a generic solver spectrum: array An array with spectrum $$S(\omega)$$ for the frequencies specified in wlist.
spectrum_ss(H, wlist, c_ops, a_op, b_op)[source]

Calculate the spectrum of the correlation function $$\lim_{t o \infty} \left<A(t+\tau)B(t)\right>$$, i.e., the Fourier transform of the correlation function:

$\begin{split}S(\omega) = \int_{-\infty}^{\infty} \lim_{t o \infty} \left<A(t+\tau)B(t)\right> e^{-i\omega\tau} d\tau.\end{split}$

using an eseries based solver Note: this spectrum is only defined for stationary statistics (uses steady state rho0).

Parameters: H : qutip.qobj system Hamiltonian. wlist : list / array list of frequencies for $$\omega$$. c_ops : list of qutip.qobj list of collapse operators. a_op : qutip.qobj operator A. b_op : qutip.qobj operator B. use_pinv : bool If True use numpy’s pinv method, otherwise use a generic solver spectrum: array An array with spectrum $$S(\omega)$$ for the frequencies specified in wlist.
spectrum_pi(H, wlist, c_ops, a_op, b_op, use_pinv=False)[source]

Calculate the spectrum of the correlation function $$\lim_{t o \infty} \left<A(t+\tau)B(t)\right>$$, i.e., the Fourier transform of the correlation function:

$\begin{split}S(\omega) = \int_{-\infty}^{\infty} \lim_{t o \infty} \left<A(t+\tau)B(t)\right> e^{-i\omega\tau} d\tau.\end{split}$

using a psuedo-inverse method. Note: this spectrum is only defined for stationary statistics (uses steady state rho0)

Parameters: H : qutip.qobj system Hamiltonian. wlist : list / array list of frequencies for $$\omega$$. c_ops : list of qutip.qobj list of collapse operators. a_op : qutip.qobj operator A. b_op : qutip.qobj operator B. use_pinv : bool If True use numpy’s pinv method, otherwise use a generic solver spectrum: array An array with spectrum $$S(\omega)$$ for the frequencies specified in wlist.
spectrum_correlation_fft(taulist, y)[source]

Calculate the power spectrum corresponding to a two-time correlation function using FFT.

Parameters: tlist : list / array list/array of times $$t$$ which the correlation function is given. y : list / array list/array of correlations corresponding to time delays $$t$$. w, S : tuple Returns an array of angular frequencies ‘w’ and the corresponding one-sided power spectrum ‘S(w)’.
coherence_function_g1(H, taulist, c_ops, a_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x105963998>)[source]

Calculate the normalized first-order quantum coherence function:

$g^{(1)}(\tau) = \lim_{t o \infty} \frac{\langle a^\dagger(t+\tau)a(t)\rangle} {\langle a^\dagger(t)a(t)\rangle}$

using the quantum regression theorem and the evolution solver indicated by the solver parameter. Note: g1 is only defined for stationary statistics (uses steady state).

Parameters: H : qutip.qobj.Qobj system Hamiltonian. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj The annihilation operator of the mode. solver : str choice of solver (me for master-equation and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. g1: array The normalized first-order coherence function.
coherence_function_g2(H, taulist, c_ops, a_op, solver='me', args=None, options=<qutip.solver.Options instance at 0x1059639e0>)[source]

Calculate the normalized second-order quantum coherence function:

$g^{(2)}(\tau) = \lim_{t o \infty} \frac{\langle a^\dagger(t)a^\dagger(t+\tau) a(t+\tau)a(t)\rangle} {\langle a^\dagger(t)a(t)\rangle^2}$

using the quantum regression theorem and the evolution solver indicated by the solver parameter. Note: g2 is only defined for stationary statistics (uses steady state rho0).

Parameters: H : qutip.qobj.Qobj system Hamiltonian. taulist : list / array list of times for $$\tau$$. taulist must be positive and contain the element 0. c_ops : list of qutip.qobj.Qobj list of collapse operators. a_op : qutip.qobj.Qobj The annihilation operator of the mode. solver : str choice of solver (me for master-equation and es for exponential series) options : qutip.solver.Options solver options class. ntraj is taken as a two-element list because the mc correlator calls mcsolve() recursively; by default, ntraj=[20, 100]. mc_corr_eps prevents divide-by-zero errors in the mc correlator; by default, mc_corr_eps=1e-10. g2: array The normalized second-order coherence function.

Module contains functions for solving for the steady state density matrix of open quantum systems defined by a Liouvillian or Hamiltonian and a list of collapse operators.

Calculates the steady state for quantum evolution subject to the supplied Hamiltonian or Liouvillian operator and (if given a Hamiltonian) a list of collapse operators.

If the user passes a Hamiltonian then it, along with the list of collapse operators, will be converted into a Liouvillian operator in Lindblad form.

Parameters: A : qobj A Hamiltonian or Liouvillian operator. c_op_list : list A list of collapse operators. method : str {‘direct’, ‘eigen’, ‘iterative-gmres’, ‘iterative-lgmres’, ‘iterative-bicgstab’, ‘svd’, ‘power’} Method for solving the underlying linear equation. Direct LU solver ‘direct’ (default), sparse eigenvalue problem ‘eigen’, iterative GMRES method ‘iterative-gmres’, iterative LGMRES method ‘iterative-lgmres’, iterative BICGSTAB method ‘iterative-bicgstab’, SVD ‘svd’ (dense), or inverse-power method ‘power’. return_info : bool, optional, default = False Return a dictionary of solver-specific infomation about the solution and how it was obtained. sparse : bool, optional, default = True Solve for the steady state using sparse algorithms. If set to False, the underlying Liouvillian operator will be converted into a dense matrix. Use only for ‘smaller’ systems. use_rcm : bool, optional, default = False Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU factorization of the Liouvillian. use_wbm : bool, optional, default = False Use Weighted Bipartite Matching reordering to make the Liouvillian diagonally dominant. This is useful for iterative preconditioners only, and is set to True by default when finding a preconditioner. weight : float, optional Sets the size of the elements used for adding the unity trace condition to the linear solvers. This is set to the average abs value of the Liouvillian elements if not specified by the user. use_umfpack : bool {False, True} Use umfpack solver instead of SuperLU. For SciPy 0.14+, this option requires installing scikits.umfpack. x0 : ndarray, optional ITERATIVE ONLY. Initial guess for solution vector. maxiter : int, optional, default=1000 ITERATIVE ONLY. Maximum number of iterations to perform. tol : float, optional, default=1e-9 ITERATIVE ONLY. Tolerance used for terminating solver. permc_spec : str, optional, default=’COLAMD’ ITERATIVE ONLY. Column ordering used internally by superLU for the ‘direct’ LU decomposition method. Options include ‘COLAMD’ and ‘NATURAL’. If using RCM then this is set to ‘NATURAL’ automatically unless explicitly specified. use_precond : bool optional, default = False ITERATIVE ONLY. Use an incomplete sparse LU decomposition as a preconditioner for the ‘iterative’ GMRES and BICG solvers. Speeds up convergence time by orders of magnitude in many cases. M : {sparse matrix, dense matrix, LinearOperator}, optional ITERATIVE ONLY. Preconditioner for A. The preconditioner should approximate the inverse of A. Effective preconditioning can dramatically improve the rate of convergence for iterative methods. If no preconditioner is given and use_precond = True, then one is generated automatically. fill_factor : float, optional, default = 100 ITERATIVE ONLY. Specifies the fill ratio upper bound (>=1) of the iLU preconditioner. Lower values save memory at the cost of longer execution times and a possible singular factorization. drop_tol : float, optional, default = 1e-4 ITERATIVE ONLY. Sets the threshold for the magnitude of preconditioner elements that should be dropped. Can be reduced for a courser factorization at the cost of an increased number of iterations, and a possible singular factorization. diag_pivot_thresh : float, optional, default = None ITERATIVE ONLY. Sets the threshold between [0,1] for which diagonal elements are considered acceptable pivot points when using a preconditioner. A value of zero forces the pivot to be the diagonal element. ILU_MILU : str, optional, default = ‘smilu_2’ ITERATIVE ONLY. Selects the incomplete LU decomposition method algoithm used in creating the preconditoner. Should only be used by advanced users. dm : qobj Steady state density matrix. info : dict, optional Dictionary containing solver-specific information about the solution.

Notes

The SVD method works only for dense operators (i.e. small systems).

build_preconditioner(A, c_op_list=[], **kwargs)[source]

Constructs a iLU preconditioner necessary for solving for the steady state density matrix using the iterative linear solvers in the ‘steadystate’ function.

Parameters: A : qobj A Hamiltonian or Liouvillian operator. c_op_list : list A list of collapse operators. return_info : bool, optional, default = False Return a dictionary of solver-specific infomation about the solution and how it was obtained. use_rcm : bool, optional, default = False Use reverse Cuthill-Mckee reordering to minimize fill-in in the LU factorization of the Liouvillian. use_wbm : bool, optional, default = False Use Weighted Bipartite Matching reordering to make the Liouvillian diagonally dominant. This is useful for iterative preconditioners only, and is set to True by default when finding a preconditioner. weight : float, optional Sets the size of the elements used for adding the unity trace condition to the linear solvers. This is set to the average abs value of the Liouvillian elements if not specified by the user. permc_spec : str, optional, default=’COLAMD’ Column ordering used internally by superLU for the ‘direct’ LU decomposition method. Options include ‘COLAMD’ and ‘NATURAL’. If using RCM then this is set to ‘NATURAL’ automatically unless explicitly specified. fill_factor : float, optional, default = 100 Specifies the fill ratio upper bound (>=1) of the iLU preconditioner. Lower values save memory at the cost of longer execution times and a possible singular factorization. drop_tol : float, optional, default = 1e-4 Sets the threshold for the magnitude of preconditioner elements that should be dropped. Can be reduced for a courser factorization at the cost of an increased number of iterations, and a possible singular factorization. diag_pivot_thresh : float, optional, default = None Sets the threshold between [0,1] for which diagonal elements are considered acceptable pivot points when using a preconditioner. A value of zero forces the pivot to be the diagonal element. ILU_MILU : str, optional, default = ‘smilu_2’ Selects the incomplete LU decomposition method algoithm used in creating the preconditoner. Should only be used by advanced users. lu : object Returns a SuperLU object representing iLU preconditioner. info : dict, optional Dictionary containing solver-specific information.

### Propagators¶

propagator(H, t, c_op_list, args=None, options=None, sparse=False, progress_bar=None)[source]

Calculate the propagator U(t) for the density matrix or wave function such that $$\psi(t) = U(t)\psi(0)$$ or $$\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)$$ where $$\rho_{\mathrm vec}$$ is the vector representation of the density matrix.

Parameters: H : qobj or list Hamiltonian as a Qobj instance of a nested list of Qobjs and coefficients in the list-string or list-function format for time-dependent Hamiltonians (see description in qutip.mesolve). t : float or array-like Time or list of times for which to evaluate the propagator. c_op_list : list List of qobj collapse operators. args : list/array/dictionary Parameters to callback functions for time-dependent Hamiltonians and collapse operators. options : qutip.Options with options for the ODE solver. progress_bar: BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation. By default no progress bar is used, and if set to True a TextProgressBar will be used. a : qobj Instance representing the propagator $$U(t)$$.

Find the steady state for successive applications of the propagator $$U$$.

Parameters: U : qobj Operator representing the propagator. a : qobj Instance representing the steady-state density matrix.

### Time-dependent problems¶

rhs_generate(H, c_ops, args={}, options=<qutip.solver.Options instance at 0x10569e200>, name=None, cleanup=True)

Generates the Cython functions needed for solving the dynamics of a given system using the mesolve function inside a parfor loop.

Parameters: H : qobj System Hamiltonian. c_ops : list list of collapse operators. args : dict Arguments for time-dependent Hamiltonian and collapse operator terms. options : Options Instance of ODE solver options. name: str Name of generated RHS cleanup: bool Whether the generated cython file should be automatically removed or not.

Notes

Using this function with any solver other than the mesolve function will result in an error.

rhs_clear()

Resets the string-format time-dependent Hamiltonian parameters.

Returns: Nothing, just clears data from internal config module.

## Visualization¶

### Pseudoprobability Functions¶

qfunc(state, xvec, yvec, g=1.4142135623730951)[source]

Q-function of a given state vector or density matrix at points xvec + i * yvec.

Parameters: state : qobj A state vector or density matrix. xvec : array_like x-coordinates at which to calculate the Wigner function. yvec : array_like y-coordinates at which to calculate the Wigner function. g : float Scaling factor for a = 0.5 * g * (x + iy), default g = sqrt(2). Q : array Values representing the Q-function calculated over the specified range [xvec,yvec].
wigner(psi, xvec, yvec, method='iterative', g=1.4142135623730951, parfor=False)[source]

Wigner function for a state vector or density matrix at points xvec + i * yvec.

Parameters: state : qobj A state vector or density matrix. xvec : array_like x-coordinates at which to calculate the Wigner function. yvec : array_like y-coordinates at which to calculate the Wigner function. Does not apply to the ‘fft’ method. g : float Scaling factor for a = 0.5 * g * (x + iy), default g = sqrt(2). method : string {‘iterative’, ‘laguerre’, ‘fft’} Select method ‘iterative’, ‘laguerre’, or ‘fft’, where ‘iterative’ uses an iterative method to evaluate the Wigner functions for density matrices $$|m>~50). parfor : bool {False, True} Flag for calculating the Laguerre polynomial based Wigner function method=’laguerre’ in parallel using the parfor function. W : array Values representing the Wigner function calculated over the specified range [xvec,yvec]. yvex : array FFT ONLY. Returns the y-coordinate values calculated via the Fourier transform. Notes The ‘fft’ method accepts only an xvec input for the x-coordinate. The y-coordinates are calculated internally. References Ulf Leonhardt, Measuring the Quantum State of Light, (Cambridge University Press, 1997) ### Graphs and Visualization¶ Functions for visualizing results of quantum dynamics simulations, visualizations of quantum states and processes. hinton(rho, xlabels=None, ylabels=None, title=None, ax=None, cmap=None, label_top=True)[source] Draws a Hinton diagram for visualizing a density matrix or superoperator. Parameters: rho : qobj Input density matrix or superoperator. xlabels : list of strings or False list of x labels ylabels : list of strings or False list of y labels title : string title of the plot (optional) ax : a matplotlib axes instance The axes context in which the plot will be drawn. cmap : a matplotlib colormap instance Color map to use when plotting. label_top : bool If True, x-axis labels will be placed on top, otherwise they will appear below the plot. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. ValueError Input argument is not a quantum object. matrix_histogram(M, xlabels=None, ylabels=None, title=None, limits=None, colorbar=True, fig=None, ax=None)[source] Draw a histogram for the matrix M, with the given x and y labels and title. Parameters: M : Matrix of Qobj The matrix to visualize xlabels : list of strings list of x labels ylabels : list of strings list of y labels title : string title of the plot (optional) limits : list/array with two float numbers The z-axis limits [min, max] (optional) ax : a matplotlib axes instance The axes context in which the plot will be drawn. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. ValueError Input argument is not valid. matrix_histogram_complex(M, xlabels=None, ylabels=None, title=None, limits=None, phase_limits=None, colorbar=True, fig=None, ax=None, threshold=None)[source] Draw a histogram for the amplitudes of matrix M, using the argument of each element for coloring the bars, with the given x and y labels and title. Parameters: M : Matrix of Qobj The matrix to visualize xlabels : list of strings list of x labels ylabels : list of strings list of y labels title : string title of the plot (optional) limits : list/array with two float numbers The z-axis limits [min, max] (optional) phase_limits : list/array with two float numbers The phase-axis (colorbar) limits [min, max] (optional) ax : a matplotlib axes instance The axes context in which the plot will be drawn. threshold: float (None) Threshold for when bars of smaller height should be transparent. If not set, all bars are colored according to the color map. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. ValueError Input argument is not valid. plot_energy_levels(H_list, N=0, labels=None, show_ylabels=False, figsize=(8, 12), fig=None, ax=None)[source] Plot the energy level diagrams for a list of Hamiltonians. Include up to N energy levels. For each element in H_list, the energy levels diagram for the cummulative Hamiltonian sum(H_list[0:n]) is plotted, where n is the index of an element in H_list. Parameters: H_list : List of Qobj A list of Hamiltonians. labels : List of string A list of labels for each Hamiltonian show_ylabels : Bool (default False) Show y labels to the left of energy levels of the initial Hamiltonian. N : int The number of energy levels to plot figsize : tuple (int,int) The size of the figure (width, height). fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. ax : a matplotlib axes instance The axes context in which the plot will be drawn. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. ValueError Input argument is not valid. plot_fock_distribution(rho, offset=0, fig=None, ax=None, figsize=(8, 6), title=None, unit_y_range=True)[source] Plot the Fock distribution for a density matrix (or ket) that describes an oscillator mode. Parameters: rho : qutip.qobj.Qobj The density matrix (or ket) of the state to visualize. fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. ax : a matplotlib axes instance The axes context in which the plot will be drawn. title : string An optional title for the figure. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_wigner_fock_distribution(rho, fig=None, axes=None, figsize=(8, 4), cmap=None, alpha_max=7.5, colorbar=False, method='iterative', projection='2d')[source] Plot the Fock distribution and the Wigner function for a density matrix (or ket) that describes an oscillator mode. Parameters: rho : qutip.qobj.Qobj The density matrix (or ket) of the state to visualize. fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. axes : a list of two matplotlib axes instances The axes context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). cmap : a matplotlib cmap instance The colormap. alpha_max : float The span of the x and y coordinates (both [-alpha_max, alpha_max]). colorbar : bool Whether (True) or not (False) a colorbar should be attached to the Wigner function graph. method : string {‘iterative’, ‘laguerre’, ‘fft’} The method used for calculating the wigner function. See the documentation for qutip.wigner for details. projection: string {‘2d’, ‘3d’} Specify whether the Wigner function is to be plotted as a contour graph (‘2d’) or surface plot (‘3d’). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_wigner(rho, fig=None, ax=None, figsize=(8, 4), cmap=None, alpha_max=7.5, colorbar=False, method='iterative', projection='2d')[source] Plot the the Wigner function for a density matrix (or ket) that describes an oscillator mode. Parameters: rho : qutip.qobj.Qobj The density matrix (or ket) of the state to visualize. fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. ax : a matplotlib axes instance The axes context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). cmap : a matplotlib cmap instance The colormap. alpha_max : float The span of the x and y coordinates (both [-alpha_max, alpha_max]). colorbar : bool Whether (True) or not (False) a colorbar should be attached to the Wigner function graph. method : string {‘iterative’, ‘laguerre’, ‘fft’} The method used for calculating the wigner function. See the documentation for qutip.wigner for details. projection: string {‘2d’, ‘3d’} Specify whether the Wigner function is to be plotted as a contour graph (‘2d’) or surface plot (‘3d’). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. sphereplot(theta, phi, values, fig=None, ax=None, save=False)[source] Plots a matrix of values on a sphere Parameters: theta : float Angle with respect to z-axis phi : float Angle in x-y plane values : array Data set to be plotted fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. ax : a matplotlib axes instance The axes context in which the plot will be drawn. save : bool {False , True} Whether to save the figure or not fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_schmidt(ket, splitting=None, labels_iteration=(3, 2), theme='light', fig=None, ax=None, figsize=(6, 6))[source] Plotting scheme related to Schmidt decomposition. Converts a state into a matrix (A_ij -> A_i^j), where rows are first particles and columns - last. See also: plot_qubism with how=’before_after’ for a similar plot. Parameters: ket : Qobj Pure state for plotting. splitting : int Plot for a number of first particles versus the rest. If not given, it is (number of particles + 1) // 2. theme : ‘light’ (default) or ‘dark’ Set coloring theme for mapping complex values into colors. See: complex_array_to_rgb. labels_iteration : int or pair of ints (default (3,2)) Number of particles to be shown as tick labels, for first (vertical) and last (horizontal) particles, respectively. fig : a matplotlib figure instance The figure canvas on which the plot will be drawn. ax : a matplotlib axis instance The axis context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_qubism(ket, theme='light', how='pairs', grid_iteration=1, legend_iteration=0, fig=None, ax=None, figsize=(6, 6))[source] Qubism plot for pure states of many qudits. Works best for spin chains, especially with even number of particles of the same dimension. Allows to see entanglement between first 2*k particles and the rest. More information: J. Rodriguez-Laguna, P. Migdal, M. Ibanez Berganza, M. Lewenstein, G. Sierra, “Qubism: self-similar visualization of many-body wavefunctions”, New J. Phys. 14 053028 (2012), arXiv:1112.3560, http://dx.doi.org/10.1088/1367-2630/14/5/053028 (open access) Parameters: ket : Qobj Pure state for plotting. theme : ‘light’ (default) or ‘dark’ Set coloring theme for mapping complex values into colors. See: complex_array_to_rgb. how : ‘pairs’ (default), ‘pairs_skewed’ or ‘before_after’ Type of Qubism plotting. Options: ‘pairs’ - typical coordinates, ‘pairs_skewed’ - for ferromagnetic/antriferromagnetic plots, ‘before_after’ - related to Schmidt plot (see also: plot_schmidt). grid_iteration : int (default 1) Helper lines to be drawn on plot. Show tiles for 2*grid_iteration particles vs all others. legend_iteration : int (default 0) or ‘grid_iteration’ or ‘all’ Show labels for first 2*legend_iteration particles. Option ‘grid_iteration’ sets the same number of particles as for grid_iteration. Option ‘all’ makes label for all particles. Typically it should be 0, 1, 2 or perhaps 3. fig : a matplotlib figure instance The figure canvas on which the plot will be drawn. ax : a matplotlib axis instance The axis context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_expectation_values(results, ylabels=[], title=None, show_legend=False, fig=None, axes=None, figsize=(8, 4))[source] Visualize the results (expectation values) for an evolution solver. results is assumed to be an instance of Result, or a list of Result instances. Parameters: results : (list of) qutip.solver.Result List of results objects returned by any of the QuTiP evolution solvers. ylabels : list of strings The y-axis labels. List should be of the same length as results. title : string The title of the figure. show_legend : bool Whether or not to show the legend. fig : a matplotlib Figure instance The Figure canvas in which the plot will be drawn. axes : a matplotlib axes instance The axes context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_spin_distribution_2d(P, THETA, PHI, fig=None, ax=None, figsize=(8, 8))[source] Plot a spin distribution function (given as meshgrid data) with a 2D projection where the surface of the unit sphere is mapped on the unit disk. Parameters: P : matrix Distribution values as a meshgrid matrix. THETA : matrix Meshgrid matrix for the theta coordinate. PHI : matrix Meshgrid matrix for the phi coordinate. fig : a matplotlib figure instance The figure canvas on which the plot will be drawn. ax : a matplotlib axis instance The axis context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. plot_spin_distribution_3d(P, THETA, PHI, fig=None, ax=None, figsize=(8, 6))[source] Plots a matrix of values on a sphere Parameters: P : matrix Distribution values as a meshgrid matrix. THETA : matrix Meshgrid matrix for the theta coordinate. PHI : matrix Meshgrid matrix for the phi coordinate. fig : a matplotlib figure instance The figure canvas on which the plot will be drawn. ax : a matplotlib axis instance The axis context in which the plot will be drawn. figsize : (width, height) The size of the matplotlib figure (in inches) if it is to be created (that is, if no ‘fig’ and ‘ax’ arguments are passed). fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure. orbital(theta, phi, *args) Calculates an angular wave function on a sphere. psi = orbital(theta,phi,ket1,ket2,...) calculates the angular wave function on a sphere at the mesh of points defined by theta and phi which is \(\sum_{lm} c_{lm} Y_{lm}(theta,phi)$$ where $$C_{lm}$$ are the coefficients specified by the list of kets. Each ket has 2l+1 components for some integer l.

Parameters: theta : list/array Polar angles phi : list/array Azimuthal angles args : list/array list of ket vectors. array for angular wave function

### Quantum Process Tomography¶

qpt(U, op_basis_list)[source]

Calculate the quantum process tomography chi matrix for a given (possibly nonunitary) transformation matrix U, which transforms a density matrix in vector form according to:

vec(rho) = U * vec(rho0)

or

rho = vec2mat(U * mat2vec(rho0))

U can be calculated for an open quantum system using the QuTiP propagator function.

Parameters: U : Qobj Transformation operator. Can be calculated using QuTiP propagator function. op_basis_list : list A list of Qobj’s representing the basis states. chi : array QPT chi matrix
qpt_plot(chi, lbls_list, title=None, fig=None, axes=None)[source]

Visualize the quantum process tomography chi matrix. Plot the real and imaginary parts separately.

Parameters: chi : array Input QPT chi matrix. lbls_list : list List of labels for QPT plot axes. title : string Plot title. fig : figure instance User defined figure instance used for generating QPT plot. axes : list of figure axis instance User defined figure axis instance (list of two axes) used for generating QPT plot. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure.
qpt_plot_combined(chi, lbls_list, title=None, fig=None, ax=None, figsize=(8, 6), threshold=None)[source]

Visualize the quantum process tomography chi matrix. Plot bars with height and color corresponding to the absolute value and phase, respectively.

Parameters: chi : array Input QPT chi matrix. lbls_list : list List of labels for QPT plot axes. title : string Plot title. fig : figure instance User defined figure instance used for generating QPT plot. ax : figure axis instance User defined figure axis instance used for generating QPT plot (alternative to the fig argument). threshold: float (None) Threshold for when bars of smaller height should be transparent. If not set, all bars are colored according to the color map. fig, ax : tuple A tuple of the matplotlib figure and axes instances used to produce the figure.

## Quantum Information Processing¶

### Gates¶

rx(phi, N=None, target=0)[source]

Single-qubit rotation for operator sigmax with angle phi.

Returns: result : qobj Quantum object for operator describing the rotation.
ry(phi, N=None, target=0)[source]

Single-qubit rotation for operator sigmay with angle phi.

Returns: result : qobj Quantum object for operator describing the rotation.
rz(phi, N=None, target=0)[source]

Single-qubit rotation for operator sigmaz with angle phi.

Returns: result : qobj Quantum object for operator describing the rotation.
sqrtnot(N=None, target=0)[source]

Single-qubit square root NOT gate.

Returns: result : qobj Quantum object for operator describing the square root NOT gate.
snot(N=None, target=0)[source]

Quantum object representing the SNOT (Hadamard) gate.

Returns: snot_gate : qobj Quantum object representation of SNOT gate.

Examples

>>> snot()
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 0.70710678+0.j  0.70710678+0.j]
[ 0.70710678+0.j -0.70710678+0.j]]

phasegate(theta, N=None, target=0)[source]

Returns quantum object representing the phase shift gate.

Parameters: theta : float Phase rotation angle. phase_gate : qobj Quantum object representation of phase shift gate.

Examples

>>> phasegate(pi/4)
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 1.00000000+0.j          0.00000000+0.j        ]
[ 0.00000000+0.j          0.70710678+0.70710678j]]

cphase(theta, N=2, control=0, target=1)[source]

Returns quantum object representing the phase shift gate.

Parameters: theta : float Phase rotation angle. N : integer The number of qubits in the target space. control : integer The index of the control qubit. target : integer The index of the target qubit. U : qobj Quantum object representation of controlled phase gate.
cnot(N=None, control=0, target=1)[source]

Quantum object representing the CNOT gate.

Returns: cnot_gate : qobj Quantum object representation of CNOT gate

Examples

>>> cnot()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]]

csign(N=None, control=0, target=1)[source]

Quantum object representing the CSIGN gate.

Returns: csign_gate : qobj Quantum object representation of CSIGN gate

Examples

>>> csign()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  -1.+0.j]]

berkeley(N=None, targets=[0, 1])[source]

Quantum object representing the Berkeley gate.

Returns: berkeley_gate : qobj Quantum object representation of Berkeley gate

Examples

>>> berkeley()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ cos(pi/8).+0.j  0.+0.j           0.+0.j           0.+sin(pi/8).j]
[ 0.+0.j          cos(3pi/8).+0.j  0.+sin(3pi/8).j  0.+0.j]
[ 0.+0.j          0.+sin(3pi/8).j  cos(3pi/8).+0.j  0.+0.j]
[ 0.+sin(pi/8).j  0.+0.j           0.+0.j           cos(pi/8).+0.j]]

swapalpha(alpha, N=None, targets=[0, 1])[source]

Quantum object representing the SWAPalpha gate.

Returns: swapalpha_gate : qobj Quantum object representation of SWAPalpha gate

Examples

>>> swapalpha(alpha)
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j                    0.+0.j                    0.+0.j]
[ 0.+0.j  0.5*(1 + exp(j*pi*alpha)  0.5*(1 - exp(j*pi*alpha)  0.+0.j]
[ 0.+0.j  0.5*(1 - exp(j*pi*alpha)  0.5*(1 + exp(j*pi*alpha)  0.+0.j]
[ 0.+0.j  0.+0.j                    0.+0.j                    1.+0.j]]

swap(N=None, targets=[0, 1])[source]

Quantum object representing the SWAP gate.

Returns: swap_gate : qobj Quantum object representation of SWAP gate

Examples

>>> swap()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]]

iswap(N=None, targets=[0, 1])[source]

Quantum object representing the iSWAP gate.

Returns: iswap_gate : qobj Quantum object representation of iSWAP gate

Examples

>>> iswap()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+1.j  0.+0.j]
[ 0.+0.j  0.+1.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]]

sqrtswap(N=None, targets=[0, 1])[source]

Quantum object representing the square root SWAP gate.

Returns: sqrtswap_gate : qobj Quantum object representation of square root SWAP gate
sqrtiswap(N=None, targets=[0, 1])[source]

Quantum object representing the square root iSWAP gate.

Returns: sqrtiswap_gate : qobj Quantum object representation of square root iSWAP gate

Examples

>>> sqrtiswap()
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 1.00000000+0.j   0.00000000+0.j          0.00000000+0.j          0.00000000+0.j]
[ 0.00000000+0.j   0.70710678+0.j          0.00000000-0.70710678j  0.00000000+0.j]
[ 0.00000000+0.j   0.00000000-0.70710678j       0.70710678+0.j          0.00000000+0.j]
[ 0.00000000+0.j   0.00000000+0.j          0.00000000+0.j          1.00000000+0.j]]

fredkin(N=None, control=0, targets=[1, 2])[source]

Quantum object representing the Fredkin gate.

Returns: fredkin_gate : qobj Quantum object representation of Fredkin gate.

Examples

>>> fredkin()
Quantum object: dims = [[2, 2, 2], [2, 2, 2]], shape = [8, 8], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j]]

toffoli(N=None, controls=[0, 1], target=2)[source]

Quantum object representing the Toffoli gate.

Returns: toff_gate : qobj Quantum object representation of Toffoli gate.

Examples

>>> toffoli()
Quantum object: dims = [[2, 2, 2], [2, 2, 2]], shape = [8, 8], type = oper, isHerm = True
Qobj data =
[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j]
[ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j]]

rotation(op, phi, N=None, target=0)[source]

Single-qubit rotation for operator op with angle phi.

Returns: result : qobj Quantum object for operator describing the rotation.
controlled_gate(U, N=2, control=0, target=1, control_value=1)[source]

Create an N-qubit controlled gate from a single-qubit gate U with the given control and target qubits.

Parameters: U : Qobj Arbitrary single-qubit gate. N : integer The number of qubits in the target space. control : integer The index of the first control qubit. target : integer The index of the target qubit. control_value : integer (1) The state of the control qubit that activates the gate U. result : qobj Quantum object representing the controlled-U gate.
globalphase(theta, N=1)[source]

Returns quantum object representing the global phase shift gate.

Parameters: theta : float Phase rotation angle. phase_gate : qobj Quantum object representation of global phase shift gate.

Examples

>>> phasegate(pi/4)
Quantum object: dims = [, ], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.70710678+0.70710678j          0.00000000+0.j]
[ 0.00000000+0.j          0.70710678+0.70710678j]]


Quantum object representing the N-qubit Hadamard gate.

Returns: q : qobj Quantum object representation of the N-qubit Hadamard gate.
gate_sequence_product(U_list, left_to_right=True)[source]

Calculate the overall unitary matrix for a given list of unitary operations

Parameters: U_list : list List of gates implementing the quantum circuit. left_to_right: Boolean Check if multiplication is to be done from left to right. U_overall: qobj Overall unitary matrix of a given quantum circuit.
gate_expand_1toN(U, N, target)[source]

Create a Qobj representing a one-qubit gate that act on a system with N qubits.

Parameters: U : Qobj The one-qubit gate N : integer The number of qubits in the target space. target : integer The index of the target qubit. gate : qobj Quantum object representation of N-qubit gate.
gate_expand_2toN(U, N, control=None, target=None, targets=None)[source]

Create a Qobj representing a two-qubit gate that act on a system with N qubits.

Parameters: U : Qobj The two-qubit gate N : integer The number of qubits in the target space. control : integer The index of the control qubit. target : integer The index of the target qubit. targets : list List of target qubits. gate : qobj Quantum object representation of N-qubit gate.
gate_expand_3toN(U, N, controls=[0, 1], target=2)[source]

Create a Qobj representing a three-qubit gate that act on a system with N qubits.

Parameters: U : Qobj The three-qubit gate N : integer The number of qubits in the target space. controls : list The list of the control qubits. target : integer The index of the target qubit. gate : qobj Quantum object representation of N-qubit gate.

### Qubits¶

qubit_states(N=1, states=)[source]

Function to define initial state of the qubits.

Parameters: N: Integer Number of qubits in the register. states: List Initial state of each qubit. qstates: Qobj List of qubits.

### Algorithms¶

qft(N=1)[source]

Quantum Fourier Transform operator on N qubits.

Parameters: N : int Number of qubits. QFT: qobj Quantum Fourier transform operator.
qft_steps(N=1, swapping=True)[source]

Quantum Fourier Transform operator on N qubits returning the individual steps as unitary matrices operating from left to right.

Parameters: N: int Number of qubits. swap: boolean Flag indicating sequence of swap gates to be applied at the end or not. U_step_list: list of qobj List of Hadamard and controlled rotation gates implementing QFT.
qft_gate_sequence(N=1, swapping=True)[source]

Quantum Fourier Transform operator on N qubits returning the gate sequence.

Parameters: N: int Number of qubits. swap: boolean Flag indicating sequence of swap gates to be applied at the end or not. qc: instance of QubitCircuit Gate sequence of Hadamard and controlled rotation gates implementing QFT.

## Optimal control¶

This module contains functions that implement the GRAPE algorithm for calculating pulse sequences for quantum systems.

plot_grape_control_fields(times, u, labels, uniform_axes=False)[source]

Plot a series of plots showing the GRAPE control fields given in the given control pulse matrix u.

Parameters: times : array Time coordinate array. u : array Control pulse matrix. labels : list List of labels for each control pulse sequence in the control pulse matrix. uniform_axes : bool Whether or not to plot all pulse sequences using the same y-axis scale.
grape_unitary(U, H0, H_ops, R, times, eps=None, u_start=None, u_limits=None, interp_kind='linear', use_interp=False, alpha=None, beta=None, phase_sensitive=True, progress_bar=<qutip.ui.progressbar.BaseProgressBar object at 0x107b6fd90>)[source]

Calculate control pulses for the Hamiltonian operators in H_ops so that the unitary U is realized.

Experimental: Work in progress.

Parameters: U : Qobj Target unitary evolution operator. H0 : Qobj Static Hamiltonian (that cannot be tuned by the control fields). H_ops: list of Qobj A list of operators that can be tuned in the Hamiltonian via the control fields. R : int Number of GRAPE iterations. time : array / list Array of time coordinates for control pulse evalutation. u_start : array Optional array with initial control pulse values. Instance of GRAPEResult, which contains the control pulses calculated with GRAPE, a time-dependent Hamiltonian that is defined by the control pulses, as well as the resulting propagator.
grape_unitary_adaptive(U, H0, H_ops, R, times, eps=None, u_start=None, u_limits=None, interp_kind='linear', use_interp=False, alpha=None, beta=None, phase_sensitive=False, overlap_terminate=1.0, progress_bar=<qutip.ui.progressbar.BaseProgressBar object at 0x107be58d0>)[source]

Calculate control pulses for the Hamiltonian operators in H_ops so that the unitary U is realized.

Experimental: Work in progress.

Parameters: U : Qobj Target unitary evolution operator. H0 : Qobj Static Hamiltonian (that cannot be tuned by the control fields). H_ops: list of Qobj A list of operators that can be tuned in the Hamiltonian via the control fields. R : int Number of GRAPE iterations. time : array / list Array of time coordinates for control pulse evalutation. u_start : array Optional array with initial control pulse values. Instance of GRAPEResult, which contains the control pulses calculated with GRAPE, a time-dependent Hamiltonian that is defined by the control pulses, as well as the resulting propagator.

Wrapper functions that will manage the creation of the objects, build the configuration, and execute the algorithm required to optimise a set of ctrl pulses for a given (quantum) system. The fidelity error is some measure of distance of the system evolution from the given target evolution in the time allowed for the evolution. The functions minimise this fidelity error wrt the piecewise control amplitudes in the timeslots

optimize_pulse(drift, ctrls, initial, target, num_tslots=None, evo_time=None, tau=None, amp_lbound=-inf, amp_ubound=inf, fid_err_targ=1e-10, min_grad=1e-10, max_iter=500, max_wall_time=180, optim_alg='LBFGSB', max_metric_corr=10, accuracy_factor=10000000.0, dyn_type='GEN_MAT', prop_type='DEF', fid_type='DEF', phase_option=None, fid_err_scale_factor=None, amp_update_mode='ALL', init_pulse_type='RND', pulse_scaling=1.0, pulse_offset=0.0, log_level=0, out_file_ext=None, gen_stats=False)[source]

Optimise a control pulse to minimise the fidelity error. The dynamics of the system in any given timeslot are governed by the combined dynamics generator, i.e. the sum of the drift+ctrl_amp[j]*ctrls[j] The control pulse is an [n_ts, len(ctrls)] array of piecewise amplitudes Starting from an intital (typically random) pulse, a multivariable optimisation algorithm attempts to determines the optimal values for the control pulse to minimise the fidelity error The fidelity error is some measure of distance of the system evolution from the given target evolution in the time allowed for the evolution.

Parameters: drift : Qobj the underlying dynamics generator of the system ctrls : List of Qobj a list of control dynamics generators. These are scaled by the amplitudes to alter the overall dynamics initial : Qobj starting point for the evolution. Typically the identity matrix target : Qobj target transformation, e.g. gate or state, for the time evolution num_tslots : integer or None number of timeslots. None implies that timeslots will be given in the tau array evo_time : float or None total time for the evolution None implies that timeslots will be given in the tau array tau : array[num_tslots] of floats or None durations for the timeslots. if this is given then num_tslots and evo_time are dervived from it None implies that timeslot durations will be equal and calculated as evo_time/num_tslots 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 fid_err_targ : float Fidelity error target. Pulse optimisation will terminate when the fidelity error falls below this value mim_grad : float Minimum gradient. When the sum of the squares of the gradients wrt to the control amplitudes falls below this value, the optimisation terminates, assuming local minima max_iter : integer Maximum number of iterations of the optimisation algorithm max_wall_time : float Maximum allowed elapsed time for the optimisation algorithm optim_alg : string Multi-variable optimisation algorithm options are BFGS, LBFGSB (see Optimizer classes for details) 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 (used only in L-BFGS-B) 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. (used only in L-BFGS-B) dyn_type : string Dynamics type, i.e. the type of matrix used to describe the dynamics. Options are UNIT, GEN_MAT, SYMPL (see Dynamics classes for details) prop_type : string Propagator type i.e. the method used to calculate the propagtors and propagtor gradient for each timeslot options are DEF, APPROX, DIAG, FRECHET, AUG_MAT DEF will use the default for the specific dyn_type (see PropagatorComputer classes for details) fid_type : string Fidelity error (and fidelity error gradient) computation method Options are DEF, UNIT, TRACEDIFF, TD_APPROX DEF will use the default for the specific dyn_type (See FideliyComputer classes for details) phase_option : string determines how global phase is treated in fidelity calculations (fid_type=’UNIT’ only). Options: PSU - global phase ignored SU - global phase included fid_err_scale_factor : float (used in TRACEDIFF FidelityComputer and subclasses only) 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. amp_update_mode : string determines whether propagators are calculated Options: DEF, ALL, DYNAMIC (needs work) DEF will use the default for the specific dyn_type (See TimeslotComputer classes for details) init_pulse_type : string type / shape of pulse(s) used to initialise the the control amplitudes. Options include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW (see PulseGen classes for details) pulse_scaling : float Linear scale factor for generated pulses By default initial pulses are generated with amplitudes in the range (-1.0, 1.0). These will be scaled by this parameter pulse_offset : float Line offset for the pulse. That is this value will be added to any initial pulses generated. log_level : integer level of messaging output from the logger. Options are attributes of qutip.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 out_file_ext : string or None files containing the initial and final control pulse amplitudes are saved to the current directory. The default name will be postfixed with this extension Setting this to None will suppress the output of files gen_stats : boolean if set to True then statistics for the optimisation run will be generated - accessible through attributes of the stats object Returns instance of OptimResult, which has attributes giving the reason for termination, final fidelity error, final evolution final amplitudes, statistics etc
optimize_pulse_unitary(H_d, H_c, U_0, U_targ, num_tslots=None, evo_time=None, tau=None, amp_lbound=-inf, amp_ubound=inf, fid_err_targ=1e-10, min_grad=1e-10, max_iter=500, max_wall_time=180, optim_alg='LBFGSB', max_metric_corr=10, accuracy_factor=10000000.0, phase_option='PSU', amp_update_mode='ALL', init_pulse_type='RND', pulse_scaling=1.0, pulse_offset=0.0, log_level=0, out_file_ext='.txt', gen_stats=False)[source]

Optimise a control pulse to minimise the fidelity error, assuming that the dynamics of the system are generated by unitary operators. This function is simply a wrapper for optimize_pulse, where the appropriate options for unitary dynamics are chosen and the parameter names are in the format familiar to unitary dynamics The dynamics of the system in any given timeslot are governed by the combined Hamiltonian, i.e. the sum of the H_d + ctrl_amp[j]*H_c[j] The control pulse is an [n_ts, len(ctrls)] array of piecewise amplitudes Starting from an intital (typically random) pulse, a multivariable optimisation algorithm attempts to determines the optimal values for the control pulse to minimise the fidelity error The maximum fidelity for a unitary system is 1, i.e. when the time evolution resulting from the pulse is equivalent to the target. And therefore the fidelity error is 1 - fidelity

Parameters: H_d : Qobj Drift (aka system) the underlying Hamiltonian of the system H_c : Qobj a list of control Hamiltonians. These are scaled by the amplitudes to alter the overall dynamics U_0 : Qobj starting point for the evolution. Typically the identity matrix U_targ : Qobj target transformation, e.g. gate or state, for the time evolution num_tslots : integer or None number of timeslots. None implies that timeslots will be given in the tau array evo_time : float or None total time for the evolution None implies that timeslots will be given in the tau array tau : array[num_tslots] of floats or None durations for the timeslots. if this is given then num_tslots and evo_time are dervived from it None implies that timeslot durations will be equal and calculated as evo_time/num_tslots 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 fid_err_targ : float Fidelity error target. Pulse optimisation will terminate when the fidelity error falls below this value mim_grad : float Minimum gradient. When the sum of the squares of the gradients wrt to the control amplitudes falls below this value, the optimisation terminates, assuming local minima max_iter : integer Maximum number of iterations of the optimisation algorithm max_wall_time : float Maximum allowed elapsed time for the optimisation algorithm optim_alg : string Multi-variable optimisation algorithm options are BFGS, LBFGSB (see Optimizer classes for details) 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 (used only in L-BFGS-B) 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. (used only in L-BFGS-B) phase_option : string determines how global phase is treated in fidelity calculations (fid_type=’UNIT’ only). Options: PSU - global phase ignored SU - global phase included amp_update_mode : string determines whether propagators are calculated Options: DEF, ALL, DYNAMIC (needs work) DEF will use the default for the specific dyn_type (See TimeslotComputer classes for details) init_pulse_type : string type / shape of pulse(s) used to initialise the the control amplitudes. Options include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW (see PulseGen classes for details) pulse_scaling : float Linear scale factor for generated pulses By default initial pulses are generated with amplitudes in the range (-1.0, 1.0). These will be scaled by this parameter pulse_offset : float Line offset for the pulse. That is this value will be added to any initial pulses generated. log_level : integer level of messaging output from the logger. Options are attributes of qutip.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 out_file_ext : string or None files containing the initial and final control pulse amplitudes are saved to the current directory. The default name will be postfixed with this extension Setting this to None will suppress the output of files gen_stats : boolean if set to True then statistics for the optimisation run will be generated - accessible through attributes of the stats object Returns instance of OptimResult, which has attributes giving the reason for termination, final fidelity error, final evolution final amplitudes, statistics etc
create_pulse_optimizer(drift, ctrls, initial, target, num_tslots=None, evo_time=None, tau=None, amp_lbound=-inf, amp_ubound=inf, fid_err_targ=1e-10, min_grad=1e-10, max_iter=500, max_wall_time=180, optim_alg='LBFGSB', max_metric_corr=10, accuracy_factor=10000000.0, dyn_type='GEN_MAT', prop_type='DEF', fid_type='DEF', phase_option=None, fid_err_scale_factor=None, amp_update_mode='ALL', init_pulse_type='RND', pulse_scaling=1.0, pulse_offset=0.0, log_level=0, gen_stats=False)[source]

Generate the objects of the appropriate subclasses required for the pulse optmisation based on the parameters given Note this method may be preferable to calling optimize_pulse if more detailed configuration is required before running the optmisation algorthim, or the algorithm will be run many times, for instances when trying to finding global the optimum or minimum time optimisation

Parameters: drift : Qobj the underlying dynamics generator of the system ctrls : List of Qobj a list of control dynamics generators. These are scaled by the amplitudes to alter the overall dynamics initial : Qobj starting point for the evolution. Typically the identity matrix target : Qobj target transformation, e.g. gate or state, for the time evolution num_tslots : integer or None number of timeslots. None implies that timeslots will be given in the tau array evo_time : float or None total time for the evolution None implies that timeslots will be given in the tau array tau : array[num_tslots] of floats or None durations for the timeslots. if this is given then num_tslots and evo_time are dervived from it None implies that timeslot durations will be equal and calculated as evo_time/num_tslots 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 fid_err_targ : float Fidelity error target. Pulse optimisation will terminate when the fidelity error falls below this value mim_grad : float Minimum gradient. When the sum of the squares of the gradients wrt to the control amplitudes falls below this value, the optimisation terminates, assuming local minima max_iter : integer Maximum number of iterations of the optimisation algorithm max_wall_time : float Maximum allowed elapsed time for the optimisation algorithm optim_alg : string Multi-variable optimisation algorithm options are BFGS, LBFGSB (see Optimizer classes for details) 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 (used only in L-BFGS-B) 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. (used only in L-BFGS-B) dyn_type : string Dynamics type, i.e. the type of matrix used to describe the dynamics. Options are UNIT, GEN_MAT, SYMPL (see Dynamics classes for details) prop_type : string Propagator type i.e. the method used to calculate the propagtors and propagtor gradient for each timeslot options are DEF, APPROX, DIAG, FRECHET, AUG_MAT DEF will use the default for the specific dyn_type (see PropagatorComputer classes for details) fid_type : string Fidelity error (and fidelity error gradient) computation method Options are DEF, UNIT, TRACEDIFF, TD_APPROX DEF will use the default for the specific dyn_type (See FideliyComputer classes for details) phase_option : string determines how global phase is treated in fidelity calculations (fid_type=’UNIT’ only). Options: PSU - global phase ignored SU - global phase included fid_err_scale_factor : float (used in TRACEDIFF FidelityComputer and subclasses only) 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. amp_update_mode : string determines whether propagators are calculated Options: DEF, ALL, DYNAMIC (needs work) DEF will use the default for the specific dyn_type (See TimeslotComputer classes for details) init_pulse_type : string type / shape of pulse(s) used to initialise the the control amplitudes. Options include: RND, LIN, ZERO, SINE, SQUARE, TRIANGLE, SAW (see PulseGen classes for details) pulse_scaling : float Linear scale factor for generated pulses By default initial pulses are generated with amplitudes in the range (-1.0, 1.0). These will be scaled by this parameter pulse_offset : float Line offset for the pulse. That is this value will be added to any initial pulses generated. log_level : integer level of messaging output from the logger. Options are attributes of qutip.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 Note value should be set using set_log_level gen_stats : boolean if set to True then statistics for the optimisation run will be generated - accessible through attributes of the stats object Instance of an Optimizer, through which the Config, Dynamics, PulseGen, and TerminationConditions objects can be accessed as attributes. The PropagatorComputer, FidelityComputer and TimeslotComputer objects can be accessed as attributes of the Dynamics object, e.g. optimizer.dynamics.fid_computer The optimisation can be run through the optimizer.run_optimization

Pulse generator - Generate pulses for the timeslots Each class defines a gen_pulse function that produces a float array of size num_tslots. Each class produces a differ type of pulse. See the class and gen_pulse function descriptions for details

create_pulse_gen(pulse_type='RND', dyn=None)[source]

Create and return a pulse generator object matching the given type. The pulse generators each produce a different type of pulse, see the gen_pulse function description for details. These are the random pulse options:

RND - Independent random value in each timeslot RNDFOURIER - Fourier series with random coefficients RNDWAVES - Summation of random waves RNDWALK1 - Random change in amplitude each timeslot RNDWALK2 - Random change in amp gradient each timeslot
These are the other non-periodic options:
LIN - Linear, i.e. contant gradient over the time ZERO - special case of the LIN pulse, where the gradient is 0
These are the periodic options
SINE - Sine wave SQUARE - Square wave SAW - Saw tooth wave TRIANGLE - Triangular wave

If a Dynamics object is passed in then this is used in instantiate the PulseGen, meaning that some timeslot and amplitude properties are copied over.

Pulse generator - Generate pulses for the timeslots Each class defines a gen_pulse function that produces a float array of size num_tslots. Each class produces a differ type of pulse. See the class and gen_pulse function descriptions for details

## Utilitiy Functions¶

### Graph Theory Routines¶

This module contains a collection of graph theory routines used mainly to reorder matrices for iterative steady state solvers.

Breadth-First-Search (BFS) of a graph in CSR or CSC matrix format starting from a given node (row). Takes Qobjs and CSR or CSC matrices as inputs.

This function requires a matrix with symmetric structure. Use A+trans(A) if original matrix is not symmetric or not sure.

Parameters: A : csc_matrix, csr_matrix Input graph in CSC or CSR matrix format start : int Staring node for BFS traversal. order : array Order in which nodes are traversed from starting node. levels : array Level of the nodes in the order that they are traversed.
graph_degree(A)[source]

Returns the degree for the nodes (rows) of a symmetric graph in sparse CSR or CSC format, or a qobj.

Parameters: A : qobj, csr_matrix, csc_matrix Input quantum object or csr_matrix. degree : array Array of integers giving the degree for each node (row).
reverse_cuthill_mckee(A, sym=False)[source]

Returns the permutation array that orders a sparse CSR or CSC matrix in Reverse-Cuthill McKee ordering. Since the input matrix must be symmetric, this routine works on the matrix A+Trans(A) if the sym flag is set to False (Default).

It is assumed by default (sym=False) that the input matrix is not symmetric. This is because it is faster to do A+Trans(A) than it is to check for symmetry for a generic matrix. If you are guaranteed that the matrix is symmetric in structure (values of matrix element do not matter) then set sym=True

Parameters: A : csc_matrix, csr_matrix Input sparse CSC or CSR sparse matrix format. sym : bool {False, True} Flag to set whether input matrix is symmetric. perm : array Array of permuted row and column indices.

Notes

This routine is used primarily for internal reordering of Lindblad superoperators for use in iterative solver routines.

References

E. Cuthill and J. McKee, “Reducing the Bandwidth of Sparse Symmetric Matrices”, ACM ‘69 Proceedings of the 1969 24th national conference, (1969).

maximum_bipartite_matching(A, perm_type='row')[source]

Returns an array of row or column permutations that removes nonzero elements from the diagonal of a nonsingular square CSC sparse matrix. Such a permutation is always possible provided that the matrix is nonsingular. This function looks at the structure of the matrix only.

The input matrix will be converted to CSC matrix format if necessary.

Parameters: A : sparse matrix Input matrix perm_type : str {‘row’, ‘column’} Type of permutation to generate. perm : array Array of row or column permutations.

Notes

This function relies on a maximum cardinality bipartite matching algorithm based on a breadth-first search (BFS) of the underlying graph[R3]_.

References

 [R3] Duff, K. Kaya, and B. Ucar, “Design, Implementation, and

Analysis of Maximum Transversal Algorithms”, ACM Trans. Math. Softw. 38, no. 2, (2011).

weighted_bipartite_matching(A, perm_type='row')[source]

Returns an array of row permutations that attempts to maximize the product of the ABS values of the diagonal elements in a nonsingular square CSC sparse matrix. Such a permutation is always possible provided that the matrix is nonsingular.

This function looks at both the structure and ABS values of the underlying matrix.

Parameters: A : csc_matrix Input matrix perm_type : str {‘row’, ‘column’} Type of permutation to generate. perm : array Array of row or column permutations.

Notes

This function uses a weighted maximum cardinality bipartite matching algorithm based on breadth-first search (BFS). The columns are weighted according to the element of max ABS value in the associated rows and are traversed in descending order by weight. When performing the BFS traversal, the row associated to a given column is the one with maximum weight. Unlike other techniques[R4]_, this algorithm does not guarantee the product of the diagonal is maximized. However, this limitation is offset by the substantially faster runtime of this method.

References

 [R4] Duff and J. Koster, “The design and use of algorithms for

permuting large entries to the diagonal of sparse matrices”, SIAM J. Matrix Anal. and Applics. 20, no. 4, 889 (1997).

### Utility Functions¶

This module contains utility functions that are commonly needed in other qutip modules.

n_thermal(w, w_th)[source]

Return the number of photons in thermal equilibrium for an harmonic oscillator mode with frequency ‘w’, at the temperature described by ‘w_th’ where $$\omega_{\rm th} = k_BT/\hbar$$.

Parameters: w : float or array Frequency of the oscillator. w_th : float The temperature in units of frequency (or the same units as w). n_avg : float or array Return the number of average photons in thermal equilibrium for a an oscillator with the given frequency and temperature.
linspace_with(start, stop, num=50, elems=[])[source]

Return an array of numbers sampled over specified interval with additional elements added.

Returns num spaced array with elements from elems inserted if not already included in set.

Returned sample array is not evenly spaced if addtional elements are added.

Parameters: start : int The starting value of the sequence. stop : int The stoping values of the sequence. num : int, optional Number of samples to generate. elems : list/ndarray, optional Requested elements to include in array samples : ndadrray Original equally spaced sample array with additional elements added.
clebsch(j1, j2, j3, m1, m2, m3)[source]

Calculates the Clebsch-Gordon coefficient for coupling (j1,m1) and (j2,m2) to give (j3,m3).

Parameters: j1 : float Total angular momentum 1. j2 : float Total angular momentum 2. j3 : float Total angular momentum 3. m1 : float z-component of angular momentum 1. m2 : float z-component of angular momentum 2. m3 : float z-component of angular momentum 3. cg_coeff : float Requested Clebsch-Gordan coefficient.
convert_unit(value, orig='meV', to='GHz')[source]

Convert an energy from unit orig to unit to.

Parameters: value : float / array The energy in the old unit. orig : string The name of the original unit (“J”, “eV”, “meV”, “GHz”, “mK”) to : string The name of the new unit (“J”, “eV”, “meV”, “GHz”, “mK”) value_new_unit : float / array The energy in the new unit.

### File I/O Functions¶

Retrieves an array of data from the requested file.

Parameters: filename : str Name of file containing reqested data. sep : str Seperator used to store data. data : array_like Data from selected file.
file_data_store(filename, data, numtype='complex', numformat='decimal', sep=', ')[source]

Stores a matrix of data to a file to be read by an external program.

Parameters: filename : str Name of data file to be stored, including extension. data: array_like Data to be written to file. numtype : str {‘complex, ‘real’} Type of numerical data. numformat : str {‘decimal’,’exp’} Format for written data. sep : str Single-character field seperator. Usually a tab, space, comma, or semicolon.

Loads data file from file named ‘filename.qu’ in current directory.

Parameters: name : str Name of data file to be loaded. qobject : instance / array_like Object retrieved from requested file.
qsave(data, name='qutip_data')[source]

Saves given data to file named ‘filename.qu’ in current directory.

Parameters: data : instance/array_like Input Python object to be stored. filename : str Name of output data file.

### Parallelization¶

This function provides functions for parallel execution of loops and function mappings, using the builtin Python module multiprocessing.

parfor(func, *args, **kwargs)[source]

Executes a multi-variable function in parallel on the local machine.

Parallel execution of a for-loop over function func for multiple input arguments and keyword arguments.

Note

From QuTiP 3.1.0, we recommend to use qutip.parallel_map instead of this function.

Parameters: func : function_type A function to run in parallel on the local machine. The function ‘func’ accepts a series of arguments that are passed to the function as variables. In general, the function can have multiple input variables, and these arguments must be passed in the same order as they are defined in the function definition. In addition, the user can pass multiple keyword arguments to the function. The following keyword argument is reserved: num_cpus : int Number of CPU’s to use. Default uses maximum number of CPU’s. Performance degrades if num_cpus is larger than the physical CPU count of your machine. result : list A list with length equal to number of input parameters containing the output from func.

Parallel execution of a mapping of values to the function task. This is functionally equivalent to:

Serial mapping function with the same call signature as parallel_map, for easy switching between serial and parallel execution. This is functionally equivalent to:

This function work as a drop-in replacement of qutip.parallel_map.

### IPython Notebook Tools¶

This module contains utility functions for using QuTiP with IPython notebooks.

Call the function tast for each value in task_vec using a cluster of IPython engines. The function task should have the signature task(value, args) or task(value) if args=None.

The client and view are the IPython.parallel client and load-balanced view that will be used in the parfor execution. If these are None, new instances will be created.

Call the function task for each value in values using a cluster of IPython engines. The function task should have the signature task(value, *args, **kwargs).

The client and view are the IPython.parallel client and load-balanced view that will be used in the parfor execution. If these are None, new instances will be created.

version_table(verbose=False)[source]

Print an HTML-formatted table with version numbers for QuTiP and its dependencies. Use it in a IPython notebook to show which versions of different packages that were used to run the notebook. This should make it possible to reproduce the environment and the calculation later on.

Returns: version_table: string Return an HTML-formatted string containing version information for QuTiP dependencies.