Functions¶

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.
Returns:	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 = [[5], [1]], shape = [5, 1], type = ket
Qobj data =
[[ 0.+0.j]
 [ 0.+0.j]
 [ 1.+0.j]
 [ 0.+0.j]
 [ 0.+0.j]]

bell_state(state='00')[source]¶

Returns the Bell state:

|B00> = 1 / sqrt(2)*[|0>|0>+|1>|1>] |B01> = 1 / sqrt(2)*[|0>|0>-|1>|1>] |B10> = 1 / sqrt(2)*[|0>|1>+|1>|0>] |B11> = 1 / sqrt(2)*[|0>|1>-|1>|0>]

Returns:	Bell_state : qobj Bell state

bra(seq, dim=2)[source]¶

Produces a multiparticle bra state for a list or string, where each element stands for state of the respective particle.

Parameters:

seq : str / list of ints or characters Each element defines state of the respective particle. (e.g. [1,1,0,1] or a string “1101”). For qubits it is also possible to use the following conventions: - ‘g’/’e’ (ground and excited state) - ‘u’/’d’ (spin up and down) - ‘H’/’V’ (horizontal and vertical polarization) Note: for dimension > 9 you need to use a list. dim : int (default: 2) / list of ints Space dimension for each particle: int if there are the same, list if they are different.

Returns:

bra : qobj

Examples

>>> bra("10")
Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
Qobj data =
[[ 0.  0.  1.  0.]]

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

>>> bra("12", 3)
Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
Qobj data =
[[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]

>>> bra("31", [5, 2])
Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
Qobj data =
[[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]

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.
Returns:	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 = [[5], [1]], 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.
Returns:	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 = [[3], [3]], 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        ]]

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
Returns:	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.

Returns:

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.
Returns:	ket : Qobj A Qobj instance that represent a Fock state in the exication-number- restricted state space defined by dims and exciations.

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.
Returns:	Requested number state :math:`left|nright>`.

Examples

>>> fock(4,3)
Quantum object: dims = [[4], [1]], 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.
Returns:	dm : qobj Density matrix representation of Fock state.

Examples

>>> fock_dm(3,1)
Quantum object: dims = [[3], [3]], 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]]

ghz_state(N=3)[source]¶

Returns the N-qubit GHZ-state.

Parameters:	N : int (default=3) Number of qubits in state
Returns:	G : qobj N-qubit GHZ-state

maximally_mixed_dm(N)[source]¶

Returns the maximally mixed density matrix for a Hilbert space of dimension N.

Parameters:	N : int Number of basis states in Hilbert space.
Returns:	dm : qobj Thermal state density matrix.

ket(seq, dim=2)[source]¶

Produces a multiparticle ket state for a list or string, where each element stands for state of the respective particle.

Parameters:

seq : str / list of ints or characters Each element defines state of the respective particle. (e.g. [1,1,0,1] or a string “1101”). For qubits it is also possible to use the following conventions: - ‘g’/’e’ (ground and excited state) - ‘u’/’d’ (spin up and down) - ‘H’/’V’ (horizontal and vertical polarization) Note: for dimension > 9 you need to use a list. dim : int (default: 2) / list of ints Space dimension for each particle: int if there are the same, list if they are different.

Returns:

ket : qobj

Examples

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

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

>>> ket("12", 3)
Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 1.]
 [ 0.]
 [ 0.]
 [ 0.]]

>>> ket("31", [5, 2])
Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 1.]
 [ 0.]
 [ 0.]]

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.
Returns:	dm : qobj Density matrix formed by outer product of Q.

Examples

>>> x=basis(3,2)
>>> ket2dm(x)
Quantum object: dims = [[3], [3]], 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]]

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.
Returns:	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.

projection(N, n, m, offset=0)[source]¶

The projection operator that projects state \(|m>\) on state \(|n>\).

Parameters:	N : int Number of basis states in Hilbert space. n, m : float The number states in the projection. offset : int (default 0) The lowest number state that is included in the finite number state representation of the projector.
Returns:	oper : qobj Requested projection operator.

qutrit_basis()[source]¶

Basis states for a three level system (qutrit)

Returns:	qstates : array Array of qutrit basis vectors

singlet_state()[source]¶

Returns the two particle singlet-state:

|S>=1/sqrt(2)*[|0>|1>-|1>|0>]

that is identical to the fourth bell state.

Returns:	Bell_state : qobj |B11> Bell state

spin_state(j, m, type='ket')[source]¶

Generates the spin state |j, m>, i.e. the eigenstate of the spin-j Sz operator with eigenvalue m.

Parameters:	j : float The spin of the state (). m : int Eigenvalue of the spin-j Sz operator. type : string {‘ket’, ‘bra’, ‘dm’} Type of state to generate.
Returns:	state : qobj Qobj quantum object for spin state

spin_coherent(j, theta, phi, type='ket')[source]¶

Generate the coherent spin state |theta, phi>.

Parameters:	j : float The spin of the state. theta : float Angle from z axis. phi : float Angle from x axis. type : string {‘ket’, ‘bra’, ‘dm’} Type of state to generate.
Returns:	state : qobj Qobj quantum object for spin coherent state

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.
Returns:	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

Parameters:	dims : list or array The quantum state dimensions array, as it would appear in a Qobj. state : list State number array.
Returns:	idx : int 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.
Returns:	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.
Returns:	state : qutip.Qobj.qobj The state as a qutip.Qobj.qobj instance.

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
Returns:	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 = [[5], [5]], 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 = [[5], [5]], 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]]

zero_ket(N, dims=None)[source]¶

Creates the zero ket vector with shape Nx1 and dimensions dims.

Parameters:	N : int Hilbert space dimensionality dims : list Optional dimensions if ket corresponds to a composite Hilbert space.
Returns:	zero_ket : qobj Zero ket on given Hilbert space.

Quantum Operators¶

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

charge(Nmax, Nmin=None, frac=1)[source]¶

Generate the diagonal charge operator over charge states from Nmin to Nmax.

Parameters:	Nmax : int Maximum charge state to consider. Nmin : int (default = -Nmax) Lowest charge state to consider. frac : float (default = 1) Specify fractional charge if needed.
Returns:	C : Qobj Charge operator over [Nmin,Nmax].

Notes

New in version 3.2.

commutator(A, B, kind='normal')[source]¶

Return the commutator of kind kind (normal, anti) of the two operators A and B.

create(N, offset=0)[source]¶

Creation (raising) operator.

Parameters:	N : int Dimension of Hilbert space.
Returns:	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 = [[4], [4]], 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.
Returns:	oper : qobj Qobj for lowering operator.

Examples

>>> destroy(4)
Quantum object: dims = [[4], [4]], 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.
Returns:	oper : qobj Displacement operator.

Examples

>>> displace(4,0.25)
Quantum object: dims = [[4], [4]], 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]]

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.
Returns:	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.
Returns:	op : Qobj A Qobj instance that represent the identity operator in the exication-number-restricted state space defined by dims and exciations.

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’]
Returns:	jmat : qobj / ndarray 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 = [[3], [3]], 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 = [[3], [3]], 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 = [[3], [3]], 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.
Returns:	oper: qobj Qobj for number operator.

Examples

>>> num(4)
Quantum object: dims = [[4], [4]], 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.
Returns:	oper : qobj Identity operator Qobj.

Examples

>>> qeye(3)
Quantum object: dims = [[3], [3]], 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.
Returns:	oper : qobj Identity operator Qobj.

momentum(N, offset=0)[source]¶

Momentum operator p=-1j/sqrt(2)*(a-a.dag())

Parameters:	N : int Number of Fock states in Hilbert space. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator.
Returns:	oper : qobj Momentum operator as Qobj.

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.
Returns:	oper : qobj Phase operator with respect to reference phase.

Notes

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

position(N, offset=0)[source]¶

Position operator x=1/sqrt(2)*(a+a.dag())

Parameters:	N : int Number of Fock states in Hilbert space. offset : int (default 0) The lowest number state that is included in the finite number state representation of the operator.
Returns:	oper : qobj Position operator as Qobj.

qdiags(diagonals, offsets, dims=None, shape=None)[source]¶

Constructs an operator from an array of diagonals.

Parameters:	diagonals : sequence of array_like Array of elements to place along the selected diagonals. offsets : sequence of ints Sequence for diagonals to be set: k=0 main diagonal k>0 kth upper diagonal k<0 kth lower diagonal dims : list, optional Dimensions for operator shape : list, tuple, optional Shape of operator. If omitted, a square operator large enough to contain the diagonals is generated.

See also

scipy.sparse.diags

Notes

This function requires SciPy 0.11+.

Examples

>>> qdiags(sqrt(range(1, 4)), 1)
Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isherm = False
Qobj data =
[[ 0.          1.          0.          0.        ]
 [ 0.          0.          1.41421356  0.        ]
 [ 0.          0.          0.          1.73205081]
 [ 0.          0.          0.          0.        ]]

qutrit_ops()[source]¶

Operators for a three level system (qutrit).

Returns:	opers: array array of qutrit operators.

qzero(N)[source]¶

Zero 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.
Returns:	qzero : qobj Zero operator Qobj.

sigmam()[source]¶

Annihilation operator for Pauli spins.

Examples

>>> sigmam()
Quantum object: dims = [[2], [2]], 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 = [[2], [2]], 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 = [[2], [2]], 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 = [[2], [2]], 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 = [[2], [2]], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 1.  0.]
 [ 0. -1.]]

spin_Jx(j)[source]¶

Spin-j x operator

Parameters:	j : float Spin of operator
Returns:	op : Qobj qobj representation of the operator.

spin_Jy(j)[source]¶

Spin-j y operator

Parameters:	j : float Spin of operator
Returns:	op : Qobj qobj representation of the operator.

spin_Jz(j)[source]¶

Spin-j z operator

Parameters:	j : float Spin of operator
Returns:	op : Qobj qobj representation of the operator.

spin_Jm(j)[source]¶

Spin-j annihilation operator

Parameters:	j : float Spin of operator
Returns:	op : Qobj qobj representation of the operator.

spin_Jp(j)[source]¶

Spin-j creation operator

Parameters:	j : float Spin of operator
Returns:	op : Qobj qobj representation of the operator.

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.
Returns:	oper : qutip.qobj.Qobj Squeezing operator.

Examples

>>> squeeze(4, 0.25)
Quantum object: dims = [[4], [4]], 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.
Returns:	oper : qutip.qobj.Qobj Squeezing operator.

tunneling(N, m=1)[source]¶

Tunneling operator with elements of the form \(\sum |N><N+m| + |N+m><N|\).

Parameters:	N : int Number of basis states in Hilbert space. m : int (default = 1) Number of excitations in tunneling event.
Returns:	T : Qobj Tunneling operator.

Notes

New in version 3.2.

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, ndarray, list If int, then shape of output operator. If list/ndarray then eigenvalues of generated 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]].
Returns:	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_dm_ginibre(N=2, rank=None, dims=None)[source]¶

Returns a Ginibre random density operator of dimension dim and rank rank by using the algorithm of [BCSZ08]. If rank is None, a full-rank (Hilbert-Schmidt ensemble) random density operator will be returned.

Parameters:	N : int Dimension of the density operator to be returned. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]]. rank : int or None Rank of the sampled density operator. If None, a full-rank density operator is generated.
Returns:	rho : Qobj An N × N density operator sampled from the Ginibre or Hilbert-Schmidt distribution.

rand_dm_hs(N=2, dims=None)[source]¶

Returns a Hilbert-Schmidt random density operator of dimension dim and rank rank by using the algorithm of [BCSZ08].

Parameters:	N : int Dimension of the density operator to be returned. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]].
Returns:	rho : Qobj A dim × dim density operator sampled from the Ginibre or Hilbert-Schmidt distribution.

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

Creates a random NxN sparse Hermitian quantum object.

If ‘N’ is an integer, uses \(H=0.5*(X+X^{+})\) where \(X\) is a randomly generated quantum operator with a given density. Else uses complex Jacobi rotations when ‘N’ is given by an array.

Parameters:	N : int, list/ndarray If int, then shape of output operator. If list/ndarray then eigenvalues of generated 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]]. pos_def : bool (default=False) Return a positive semi-definite matrix (by diagonal dominance).
Returns:	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 Left-dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N]].
Returns:	oper : qobj Nx1 ket state quantum operator.

rand_ket_haar(N=2, dims=None)[source]¶

Returns a Haar random pure state of dimension dim by applying a Haar random unitary to a fixed pure state.

Parameters:	N : int Dimension of the state vector to be returned. dims : list of ints, or None Left-dimensions of the resultant quantum object. If None, [N] is used.
Returns:	psi : Qobj A random state vector drawn from the Haar measure.

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]].
Returns:	oper : qobj NxN Unitary quantum operator.

rand_unitary_haar(N=2, dims=None)[source]¶

Returns a Haar random unitary matrix of dimension dim, using the algorithm of [Mez07].

Parameters:	N : int Dimension of the unitary to be returned. dims : list of lists of int, or None Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[N],[N]].
Returns:	U : Qobj Unitary of dims [[dim], [dim]] drawn from the Haar measure.

rand_super(N=5, dims=None)[source]¶

Returns a randomly drawn superoperator acting on operators acting on N dimensions.

Parameters:	N : int Square root of the dimension of the superoperator to be returned. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[[N],[N]], [[N],[N]]].

rand_super_bcsz(N=2, enforce_tp=True, rank=None, dims=None)[source]¶

Returns a random superoperator drawn from the Bruzda et al ensemble for CPTP maps [BCSZ08]. Note that due to finite numerical precision, for ranks less than full-rank, zero eigenvalues may become slightly negative, such that the returned operator is not actually completely positive.

Parameters:

N : int Square root of the dimension of the superoperator to be returned. enforce_tp : bool If True, the trace-preserving condition of [BCSZ08] is enforced; otherwise only complete positivity is enforced. rank : int or None Rank of the sampled superoperator. If None, a full-rank superoperator is generated. dims : list Dimensions of quantum object. Used for specifying tensor structure. Default is dims=[[[N],[N]], [[N],[N]]].

Returns:

rho : Qobj A superoperator acting on vectorized dim × dim density operators, sampled from the BCSZ distribution.

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>

References

The naming of qutip operators follows the convention in [R0be8dcf25d86-1] .

three_level_basis()[source]¶

Basis states for a three level atom.

Returns:	states : array array of three level atom basis vectors.

three_level_ops()[source]¶

Operators for a three level system (qutrit)

Returns:	ops : array array of three level operators.

Superoperators and Liouvillians¶

operator_to_vector(op)[source]¶

Create a vector representation of a quantum operator given the matrix representation.

vector_to_operator(op)[source]¶

Create a matrix representation given a quantum operator in vector form.

liouvillian(H, c_ops=[], data_only=False, chi=None)[source]¶

Assembles the Liouvillian superoperator from a Hamiltonian and a list of collapse operators. Like liouvillian, but with an experimental implementation which avoids creating extra Qobj instances, which can be advantageous for large systems.

Parameters:	H : qobj System Hamiltonian. c_ops : array_like A list or array of collapse operators.
Returns:	L : qobj Liouvillian superoperator.

spost(A)[source]¶

Superoperator formed from post-multiplication by operator A

Parameters:	A : qobj Quantum operator for post multiplication.
Returns:	super : qobj Superoperator formed from input qauntum object.

spre(A)[source]¶

Superoperator formed from pre-multiplication by operator A.

Parameters:	A : qobj Quantum operator for pre-multiplication.
Returns:	super :qobj Superoperator formed from input quantum object.

sprepost(A, B)[source]¶

Superoperator formed from pre-multiplication by operator A and post- multiplication of operator B.

Parameters:	A : Qobj Quantum operator for pre-multiplication. B : Qobj Quantum operator for post-multiplication.
Returns:	super : Qobj Superoperator formed from input quantum objects.

lindblad_dissipator(a, b=None, data_only=False)[source]¶

Lindblad dissipator (generalized) for a single pair of collapse operators (a, b), or for a single collapse operator (a) when b is not specified:

\[\mathcal{D}[a,b]\rho = a \rho b^\dagger - \frac{1}{2}a^\dagger b\rho - \frac{1}{2}\rho a^\dagger b\]

Parameters:	a : qobj Left part of collapse operator. b : qobj (optional) Right part of collapse operator. If not specified, b defaults to a.
Returns:	D : qobj Lindblad dissipator superoperator.

Superoperator Representations¶

This module implements transformations between superoperator representations, including supermatrix, Kraus, Choi and Chi (process) matrix formalisms.

to_choi(q_oper)[source]¶

Converts a Qobj representing a quantum map to the Choi representation, such that the trace of the returned operator is equal to the dimension of the system.

Parameters:	q_oper : Qobj Superoperator to be converted to Choi representation. If q_oper is type="oper", then it is taken to act by conjugation, such that to_choi(A) == to_choi(sprepost(A, A.dag())).
Returns:	choi : Qobj A quantum object representing the same map as q_oper, such that choi.superrep == "choi".
Raises:	TypeError: if the given quantum object is not a map, or cannot be converted to Choi representation.

to_super(q_oper)[source]¶

Converts a Qobj representing a quantum map to the supermatrix (Liouville) representation.

Parameters:	q_oper : Qobj Superoperator to be converted to supermatrix representation. If q_oper is type="oper", then it is taken to act by conjugation, such that to_super(A) == sprepost(A, A.dag()).
Returns:	superop : Qobj A quantum object representing the same map as q_oper, such that superop.superrep == "super".
Raises:	TypeError If the given quantum object is not a map, or cannot be converted to supermatrix representation.

to_kraus(q_oper)[source]¶

Converts a Qobj representing a quantum map to a list of quantum objects, each representing an operator in the Kraus decomposition of the given map.

Parameters:	q_oper : Qobj Superoperator to be converted to Kraus representation. If q_oper is type="oper", then it is taken to act by conjugation, such that to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A].
Returns:	kraus_ops : list of Qobj A list of quantum objects, each representing a Kraus operator in the decomposition of q_oper.
Raises:	TypeError: if the given quantum object is not a map, or cannot be decomposed into Kraus operators.

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.
Returns:	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..
Returns:	var : float Variance of operator ‘oper’ for given state.

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.
Returns:	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".
Returns:	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.
Returns:	cqobj : Qobj The original Qobj with all named index pairs contracted away.

Partial Transpose¶

partial_transpose(rho, mask, method='dense')[source]¶

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[0]), 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).
Returns:	rho_pr: :class:`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.
Returns:	concur : float Concurrence

References

[1]	http://en.wikipedia.org/wiki/Concurrence_(quantum_computing)

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

Calculates the conditional entropy \(S(A|B)=S(A,B)-S(B)\) of a selected 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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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.
Returns:	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, target=None)[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. target : Qobj Quantum object representing the target unitary; the inverse is applied before evaluating the fidelity.
Returns:	fid : float Fidelity pseudo-metric between A and the identity superoperator, or between A and the target superunitary.

process_fidelity(U1, U2, normalize=True)[source]¶

Calculate the process fidelity given two process operators.

Continuous 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 List of operators that defines the basis for the correlation matrix. rho : 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.
Returns:	corr_mat : ndarray 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 List of operators that defines the basis for the covariance matrix. rho : Qobj Density matrix for which to calculate the covariance matrix. symmetrized : bool {True, False} Flag indicating whether the symmetrized (default) or non-symmetrized correlation matrix is to be calculated.
Returns:	corr_mat : ndarray A 2-dimensional array of covariance values.

correlation_matrix_field(a1, a2, rho=None)[source]¶

Calculates 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 : Qobj Field operator for mode 1. a2 : Qobj Field operator for mode 2. rho : Qobj Density matrix for which to calculate the covariance matrix.
Returns:	cov_mat : ndarray Array of complex numbers or Qobj’s A 2-dimensional array of covariance values, or, if rho=0, a matrix of operators.

correlation_matrix_quadrature(a1, a2, rho=None)[source]¶

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 : Qobj Field operator for mode 1. a2 : Qobj Field operator for mode 2. rho : Qobj Density matrix for which to calculate the covariance matrix.
Returns:	corr_mat : ndarray Array of complex numbers or Qobj’s 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]¶

Calculates 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 : Qobj Field operator for mode 1. a2 : Qobj Field operator for mode 2. R : ndarray The quadrature correlation matrix. rho : Qobj Density matrix for which to calculate the covariance matrix.
Returns:	cov_mat : ndarray A 2-dimensional array of covariance values.

logarithmic_negativity(V)[source]¶

Calculates the logarithmic negativity given a 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.
Returns:	N : float The logarithmic negativity for the two-mode Gaussian state that is described by the the Wigner covariance matrix V.

Schrödinger Equation¶

This module provides solvers for the unitary Schrodinger equation.

sesolve(H, psi0, tlist, e_ops=[], args={}, options=None, progress_bar=None, _safe_mode=True)[source]¶

Schrodinger equation evolution of a state vector or unitary matrix for a given Hamiltonian.

Evolve the state vector (psi0) using a given Hamiltonian (H), by integrating the set of ordinary differential equations that define the system. Alternatively evolve a unitary matrix in solving the Schrodinger operator equation.

The output is either the state vector or unitary matrix 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. e_ops cannot be used in conjunction with solving the Schrodinger operator equation

Parameters:

H : qutip.qobj system Hamiltonian, or a callback function for time-dependent Hamiltonians. psi0 : qutip.qobj initial state vector (ket) or initial unitary operator psi0 = U 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. Must be empty list operator evolution args : dictionary dictionary of parameters for time-dependent Hamiltonians options : qutip.Qdeoptions with options for the ODE solver. progress_bar : BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation.

Returns:

output: :class:`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 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, _safe_mode=True)[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

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:

H : qutip.Qobj 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.

Returns:

result: :class:`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, _safe_mode=True)[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:

H : qutip.Qobj 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.

Returns:

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).

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.
Returns:	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.
Returns:	eseries : qutip.eseries eseries represention of the system dynamics.

Bloch-Redfield Master Equation¶

brmesolve(H, psi0, tlist, a_ops=[], e_ops=[], c_ops=[], args={}, use_secular=True, sec_cutoff=0.1, tol=1e-12, spectra_cb=None, options=None, progress_bar=None, _safe_mode=True, verbose=False)[source]¶

Solves for the dynamics of a system using the Bloch-Redfield master equation, given an input Hamiltonian, Hermitian bath-coupling terms and their associated spectrum functions, as well as possible Lindblad collapse operators.

For time-independent systems, the Hamiltonian must be given as a Qobj, whereas the bath-coupling terms (a_ops), must be written as a nested list of operator - spectrum function pairs, where the frequency is specified by the w variable.

Example

a_ops = [[a+a.dag(),lambda w: 0.2*(w>=0)]]

For time-dependent systems, the Hamiltonian, a_ops, and Lindblad collapse operators (c_ops), can be specified in the QuTiP string-based time-dependent format. For the a_op spectra, the frequency variable must be w, and the string cannot contain any other variables other than the possibility of having a time-dependence through the time variable t:

Example

a_ops = [[a+a.dag(), ‘0.2*exp(-t)*(w>=0)’]]

It is also possible to use Cubic_Spline objects for time-dependence. In the case of a_ops, Cubic_Splines must be passed as a tuple:

Example

a_ops = [ [a+a.dag(), ( f(w), g(t)] ]

where f(w) and g(t) are strings or Cubic_spline objects for the bath spectrum and time-dependence, respectively.

Finally, if one has bath-couplimg terms of the form H = f(t)*a + conj[f(t)]*a.dag(), then the correct input format is

Example

a_ops = [ [(a,a.dag()), (f(w), g1(t), g2(t))],… ]

where f(w) is the spectrum of the operators while g1(t) and g2(t) are the time-dependence of the operators a and a.dag(), respectively

Parameters:

H : Qobj / list System Hamiltonian given as a Qobj or nested list in string-based format. psi0: Qobj Initial density matrix or state vector (ket). tlist : array_like List of times for evaluating evolution a_ops : list Nested list of Hermitian system operators that couple to the bath degrees of freedom, along with their associated spectra. e_ops : list List of operators for which to evaluate expectation values. c_ops : list List of system collapse operators, or nested list in string-based format. args : dict Placeholder for future implementation, kept for API consistency. use_secular : bool {True} Use secular approximation when evaluating bath-coupling terms. sec_cutoff : float {0.1} Cutoff for secular approximation. tol : float {qutip.setttings.atol} Tolerance used for removing small values after basis transformation. spectra_cb : list DEPRECIATED. Do not use. options : qutip.solver.Options Options for the solver. progress_bar : BaseProgressBar Optional instance of BaseProgressBar, or a subclass thereof, for showing the progress of the simulation.

Returns:

result: :class:`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()¶

Calculates the time-independent Bloch-Redfield tensor for a system given a set of operators and corresponding spectral functions that describes the system’s couplingto its environment.

Parameters:

H : qutip.qobj System Hamiltonian. a_ops : list Nested list of system operators that couple to the environment, and the corresponding bath spectra represented as Python functions. spectra_cb : list Depreciated. c_ops : list List of system collapse operators. use_secular : bool {True, False} Flag that indicates if the secular approximation should be used. sec_cutoff : float {0.1} Threshold for secular approximation. atol : float {qutip.settings.atol} Threshold for removing small parameters.

Returns:

R, kets: :class:`qutip.Qobj`, list of :class:`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, progress_bar=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.
Returns:	output: :class:`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 object>, floquet_basis=True, kmax=5, _safe_mode=True)[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).

Returns:

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.

Returns:

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.
Returns:	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
Returns:	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.
Returns:	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.
Returns:	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.

Returns:

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.
Returns:	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.

Returns:

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=[], _safe_mode=True, **kwargs)[source]¶

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

Parameters:

H : qutip.Qobj 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.

Returns:

output: :class:`qutip.solver.SolverResult` An instance of the class qutip.solver.SolverResult.

ssesolve(H, psi0, times, sc_ops=[], e_ops=[], _safe_mode=True, **kwargs)[source]¶

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

Parameters:

H : qutip.Qobj 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.

Returns:

output: :class:`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:

H : qutip.Qobj 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.

Returns:

output: :class:`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:

H : qutip.Qobj 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.

Returns:

output: :class:`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={}, options=<qutip.solver.Options object>)[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 : Qobj system Hamiltonian, may be time-dependent for solver choice of me or mc. state0 : 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 : array_like 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. when \(t \rightarrow \infty\); here tlist is automatically set, ignoring user input. taulist : array_like list of times for \(\tau\). taulist must be positive and contain the element 0. c_ops : list list of collapse operators, may be time-dependent for solver choice of me or mc. a_op : Qobj operator A. b_op : Qobj operator B. reverse : bool If True, calculate \(\left<A(t)B(t+\tau)\right>\) instead of \(\left<A(t+\tau)B(t)\right>\). solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series). options : 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.

Returns:

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.

References

See, Gardiner, Quantum Noise, Section 5.2.

correlation_ss(H, taulist, c_ops, a_op, b_op, solver='me', reverse=False, args={}, options=<qutip.solver.Options object>)[source]¶

Calculate the two-operator two-time correlation function:

\[\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>\]

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 : Qobj system Hamiltonian. taulist : array_like list of times for \(\tau\). taulist must be positive and contain the element 0. c_ops : list list of collapse operators. a_op : Qobj operator A. b_op : Qobj operator B. reverse : bool If True, calculate \(\lim_{t \to \infty} \left<A(t)B(t+\tau)\right>\) instead of \(\lim_{t \to \infty} \left<A(t+\tau)B(t)\right>\). solver : str choice of solver (me for master-equation and es for exponential series). options : 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.

Returns:

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={}, options=<qutip.solver.Options object>)[source]¶

Calculate the two-operator two-time correlation function: \(\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 : Qobj system Hamiltonian, may be time-dependent for solver choice of me or mc. state0 : 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 : array_like list of times for \(\tau\). taulist must be positive and contain the element 0. c_ops : list list of collapse operators, may be time-dependent for solver choice of me or mc. a_op : Qobj operator A. b_op : Qobj operator B. reverse : bool {False, True} If True, calculate \(\left<A(t)B(t+\tau)\right>\) instead of \(\left<A(t+\tau)B(t)\right>\). solver : str {‘me’, ‘mc’, ‘es’} choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series). options : 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.

Returns:

corr_vec : ndarray 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={}, options=<qutip.solver.Options object>)[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 : Qobj system Hamiltonian, may be time-dependent for solver choice of me or mc. state0 : 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 : array_like 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. when \(t \rightarrow \infty\); here tlist is automatically set, ignoring user input. taulist : array_like list of times for \(\tau\). taulist must be positive and contain the element 0. c_ops : list list of collapse operators, may be time-dependent for solver choice of me or mc. a_op : Qobj operator A. b_op : Qobj operator B. reverse : bool {False, True} If True, calculate \(\left<A(t)B(t+\tau)\right>\) instead of \(\left<A(t+\tau)B(t)\right>\). solver : str choice of solver (me for master-equation, mc for Monte Carlo, and es for exponential series). options : 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.

Returns:

corr_mat : ndarray 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.

References

See, Gardiner, Quantum Noise, Section 5.2.