diff --git a/dev/api/index.html b/dev/api/index.html index e17e5fb..c6a0d07 100644 --- a/dev/api/index.html +++ b/dev/api/index.html @@ -1,36 +1,36 @@ -API · QuantumOpticsBase.jl
Edit on GitHub

API

Types

QuantumInterface.Basis — Type

Abstract base class for all specialized bases.

The Basis class is meant to specify a basis of the Hilbert space of the studied system. Besides basis specific information all subclasses must implement a shape variable which indicates the dimension of the used Hilbert space. For a spin-1/2 Hilbert space this would be the vector [2]. A system composed of two spins would then have a shape vector [2 2].

Composite systems can be defined with help of the CompositeBasis class.

QuantumInterface.GenericBasis — Type
GenericBasis(N)

A general purpose basis of dimension N.

Should only be used rarely since it defeats the purpose of checking that the bases of state vectors and operators are correct for algebraic operations. The preferred way is to specify special bases for different systems.

QuantumInterface.CompositeBasis — Type
CompositeBasis(b1, b2...)

Basis for composite Hilbert spaces.

Stores the subbases in a vector and creates the shape vector directly from the shape vectors of these subbases. Instead of creating a CompositeBasis directly tensor(b1, b2...) or b1 ⊗ b2 ⊗ … can be used.

  • States
QuantumInterface.StateVector — Type

Abstract base class for Bra and Ket states.

The state vector class stores the coefficients of an abstract state in respect to a certain basis. These coefficients are stored in the data field and the basis is defined in the basis field.

  • General purpose QuantumOpticsBase. A few more specialized operators are implemented in API: Quantum-systems.
QuantumInterface.AbstractOperator — Type

Abstract base class for all operators.

All deriving operator classes have to define the fields basis_l and basis_r defining the left and right side bases.

For fast time evolution also at least the function mul!(result::Ket,op::AbstractOperator,x::Ket,alpha,beta) should be implemented. Many other generic multiplication functions can be defined in terms of this function and are provided automatically.

QuantumOpticsBase.DataOperator — Type

Abstract type for operators with a data field.

This is an abstract type for operators that have a direct matrix representation stored in their .data field.

source
QuantumOpticsBase.Operator — Type
Operator{BL,BR,T} <: DataOperator{BL,BR}

Operator type that stores the representation of an operator on the Hilbert spaces given by BL and BR (e.g. a Matrix).

source
QuantumOpticsBase.SparseOperator — Function
SparseOperator(b1[, b2, data])

Sparse array implementation of Operator.

The matrix is stored as the julia built-in type SparseMatrixCSC in the data field.

source
QuantumOpticsBase.LazyTensor — Type
LazyTensor(b1[, b2], indices, operators[, factor=1])

Lazy implementation of a tensor product of operators.

The suboperators are stored in the operators field. The indices field specifies in which subsystem the corresponding operator lives. Note that these must be sorted. Additionally, a factor is stored in the factor field which allows for fast multiplication with numbers.

source
QuantumOpticsBase.LazySum — Type
LazySum([Tf,] [factors,] operators)
+API · QuantumOpticsBase.jl
Edit on GitHub
API
Types
QuantumInterface.Basis — Type
Abstract base class for all specialized bases.
The Basis class is meant to specify a basis of the Hilbert space of the studied system. Besides basis specific information all subclasses must implement a shape variable which indicates the dimension of the used Hilbert space. For a spin-1/2 Hilbert space this would be the vector [2]. A system composed of two spins would then have a shape vector [2 2].
Composite systems can be defined with help of the CompositeBasis class.
QuantumInterface.GenericBasis — Type
GenericBasis(N)
A general purpose basis of dimension N.
Should only be used rarely since it defeats the purpose of checking that the bases of state vectors and operators are correct for algebraic operations. The preferred way is to specify special bases for different systems.
QuantumInterface.CompositeBasis — Type
CompositeBasis(b1, b2...)
Basis for composite Hilbert spaces.
Stores the subbases in a vector and creates the shape vector directly from the shape vectors of these subbases. Instead of creating a CompositeBasis directly tensor(b1, b2...) or b1 ⊗ b2 ⊗ … can be used.
  • States
QuantumInterface.StateVector — Type
Abstract base class for Bra and Ket states.
The state vector class stores the coefficients of an abstract state in respect to a certain basis. These coefficients are stored in the data field and the basis is defined in the basis field.
  • General purpose QuantumOpticsBase. A few more specialized operators are implemented in API: Quantum-systems.
QuantumInterface.AbstractOperator — Type
Abstract base class for all operators.
All deriving operator classes have to define the fields basis_l and basis_r defining the left and right side bases.
For fast time evolution also at least the function mul!(result::Ket,op::AbstractOperator,x::Ket,alpha,beta) should be implemented. Many other generic multiplication functions can be defined in terms of this function and are provided automatically.
QuantumOpticsBase.DataOperator — Type
Abstract type for operators with a data field.
This is an abstract type for operators that have a direct matrix representation stored in their .data field.
source
QuantumOpticsBase.Operator — Type
Operator{BL,BR,T} <: DataOperator{BL,BR}
Operator type that stores the representation of an operator on the Hilbert spaces given by BL and BR (e.g. a Matrix).
source
QuantumOpticsBase.SparseOperator — Function
SparseOperator(b1[, b2, data])
Sparse array implementation of Operator.
The matrix is stored as the julia built-in type SparseMatrixCSC in the data field.
source
QuantumOpticsBase.LazyTensor — Type
LazyTensor(b1[, b2], indices, operators[, factor=1])
Lazy implementation of a tensor product of operators.
The suboperators are stored in the operators field. The indices field specifies in which subsystem the corresponding operator lives. Note that these must be sorted. Additionally, a factor is stored in the factor field which allows for fast multiplication with numbers.
source
QuantumOpticsBase.LazySum — Type
LazySum([Tf,] [factors,] operators)
 LazySum([Tf,] basis_l, basis_r, [factors,] [operators])
-LazySum(::Tuple, x::LazySum)
Lazy evaluation of sums of operators.
All operators have to be given in respect to the same bases. The field factors accounts for an additional multiplicative factor for each operator stored in the operators field.
The factor type Tf can be specified to avoid having to infer it from the factors and operators themselves. All factors will be converted to type Tf.
The operators will be kept as is. It can be, for example, a Tuple or a Vector of operators. Using a Tuple is recommended for runtime performance of operator-state operations, such as simulating time evolution. A Vector can reduce compile-time overhead when doing arithmetic on LazySums, such as summing many LazySums together.
To convert a vector-based LazySum x to use a tuple for operator storage, use LazySum(::Tuple, x). 
source
QuantumOpticsBase.LazyProduct — Type
LazyProduct(operators[, factor=1])
-LazyProduct(op1, op2...)
Lazy evaluation of products of operators.
The factors of the product are stored in the operators field. Additionally a complex factor is stored in the factor field which allows for fast multiplication with numbers.
source
  • Time-dependent operators.
QuantumOpticsBase.AbstractTimeDependentOperator — Type
AbstractTimeDependentOperator{BL,BR} <: AbstractOperator{BL,BR}
Abstract type providing a time-dependent operator interface. Time-dependent operators have internal "clocks" that can be addressed with set_time! and current_time. A shorthand op(t), equivalent to set_time!(copy(op), t), is available for brevity.
A time-dependent operator is always concrete-valued according to the current time of its internal clock.
source
QuantumOpticsBase.TimeDependentSum — Type
TimeDependentSum(lazysum, coeffs, init_time)
+LazySum(::Tuple, x::LazySum)
Lazy evaluation of sums of operators.
All operators have to be given in respect to the same bases. The field factors accounts for an additional multiplicative factor for each operator stored in the operators field.
The factor type Tf can be specified to avoid having to infer it from the factors and operators themselves. All factors will be converted to type Tf.
The operators will be kept as is. It can be, for example, a Tuple or a Vector of operators. Using a Tuple is recommended for runtime performance of operator-state operations, such as simulating time evolution. A Vector can reduce compile-time overhead when doing arithmetic on LazySums, such as summing many LazySums together.
To convert a vector-based LazySum x to use a tuple for operator storage, use LazySum(::Tuple, x). 
source
QuantumOpticsBase.LazyProduct — Type
LazyProduct(operators[, factor=1])
+LazyProduct(op1, op2...)
Lazy evaluation of products of operators.
The factors of the product are stored in the operators field. Additionally a complex factor is stored in the factor field which allows for fast multiplication with numbers.
source
  • Time-dependent operators.
QuantumOpticsBase.AbstractTimeDependentOperator — Type
AbstractTimeDependentOperator{BL,BR} <: AbstractOperator{BL,BR}
Abstract type providing a time-dependent operator interface. Time-dependent operators have internal "clocks" that can be addressed with set_time! and current_time. A shorthand op(t), equivalent to set_time!(copy(op), t), is available for brevity.
A time-dependent operator is always concrete-valued according to the current time of its internal clock.
source
QuantumOpticsBase.TimeDependentSum — Type
TimeDependentSum(lazysum, coeffs, init_time)
 TimeDependentSum(::Type{Tf}, basis_l, basis_r; init_time=0.0)
 TimeDependentSum([::Type{Tf},] [basis_l,] [basis_r,] coeffs, operators; init_time=0.0)
 TimeDependentSum([::Type{Tf},] coeff1=>op1, coeff2=>op2, ...; init_time=0.0)
-TimeDependentSum(::Tuple, op::TimeDependentSum)
Lazy sum of operators with time-dependent coefficients. Wraps a LazySum lazysum, adding a current_time (or operator "clock") and a means of specifying time coefficients as functions of time (or numbers).
The coefficient type Tf may be specified explicitly. Time-dependent coefficients will be converted to this type on evaluation.
source
  • Super operators:
Functions
  • Functions to generate general states, operators and super-operators
QuantumOpticsBase.basisstate — Function
basisstate([T=ComplexF64, ]b, index)
Basis vector specified by index as ket state.
For a composite system index can be a vector which then creates a tensor product state $|i_1⟩⊗|i_2⟩⊗…⊗|i_n⟩$ of the corresponding basis states.
source
basisstate([T=ComplexF64,] mb::ManyBodyBasis, occupation::Vector)
Return a ket state where the system is in the state specified by the given occupation numbers.
source
QuantumInterface.identityoperator — Function
identityoperator(a::Basis[, b::Basis])
+TimeDependentSum(::Tuple, op::TimeDependentSum)
Lazy sum of operators with time-dependent coefficients. Wraps a LazySum lazysum, adding a current_time (or operator "clock") and a means of specifying time coefficients as functions of time (or numbers).
The coefficient type Tf may be specified explicitly. Time-dependent coefficients will be converted to this type on evaluation.
source
  • Super operators:
Functions
  • Functions to generate general states, operators and super-operators
QuantumOpticsBase.basisstate — Function
basisstate([T=ComplexF64, ]b, index)
Basis vector specified by index as ket state.
For a composite system index can be a vector which then creates a tensor product state $|i_1⟩⊗|i_2⟩⊗…⊗|i_n⟩$ of the corresponding basis states.
source
basisstate([T=ComplexF64,] mb::ManyBodyBasis, occupation::Vector)
Return a ket state where the system is in the state specified by the given occupation numbers.
source
QuantumInterface.identityoperator — Function
identityoperator(a::Basis[, b::Basis])
 identityoperator(::Type{<:AbstractOperator}, a::Basis[, b::Basis])
 identityoperator(::Type{<:Number}, a::Basis[, b::Basis])
-identityoperator(::Type{<:AbstractOperator}, ::Type{<:Number}, a::Basis[, b::Basis])
Return an identityoperator in the given bases. One can optionally specify the container type which has to a subtype of AbstractOperator as well as the number type to be used in the identity matrix.
QuantumOpticsBase.spre — Function
spre(op)
Create a super-operator equivalent for right side operator multiplication.
For operators $A$, $B$ the relation
\[    \mathrm{spre}(A) B = A B\]
holds. op can be a dense or a sparse operator.
source
QuantumOpticsBase.spost — Function
spost(op)
Create a super-operator equivalent for left side operator multiplication.
For operators $A$, $B$ the relation
\[    \mathrm{spost}(A) B = B A\]
holds. op can be a dense or a sparse operator.
source
QuantumOpticsBase.sprepost — Function
sprepost(op)
Create a super-operator equivalent for left and right side operator multiplication.
For operators $A$, $B$, $C$ the relation
\[    \mathrm{sprepost}(A, B) C = A C B\]
holds. A ond B can be dense or a sparse operators.
source
QuantumOpticsBase.liouvillian — Function
liouvillian(H, J; rates, Jdagger)
Create a super-operator equivalent to the master equation so that $\dot ρ = S ρ$.
The super-operator $S$ is defined by
\[S ρ = -\frac{i}{ħ} [H, ρ] + \sum_i J_i ρ J_i^† - \frac{1}{2} J_i^† J_i ρ - \frac{1}{2} ρ J_i^† J_i\]
Arguments
  • H: Hamiltonian.
  • J: Vector containing the jump operators.
  • rates: Vector or matrix specifying the coefficients for the jump operators.
  • Jdagger: Vector containing the hermitian conjugates of the jump operators. If they            are not given they are calculated automatically.
source
  • As far as it makes sense the same functions are implemented for bases, states, operators and superQuantumOpticsBase.
QuantumInterface.tensor — Function
tensor(x, y, z...)
Tensor product of the given objects. Alternatively, the unicode symbol ⊗ (\otimes) can be used.
LinearAlgebra.tr — Function
tr(x::AbstractOperator)
Trace of the given operator.
QuantumInterface.ptrace — Function
ptrace(a, indices)
Partial trace of the given basis, state or operator.
The indices argument, which can be a single integer or a vector of integers, specifies which subsystems are traced out. The number of indices has to be smaller than the number of subsystems, i.e. it is not allowed to perform a full trace.
LinearAlgebra.normalize! — Method
normalize!(x::StateVector)
In-place normalization of the given bra or ket so that norm(x) is one.
QuantumInterface.expect — Function
expect(index, op, state)
If an index is given, it assumes that op is defined in the subsystem specified by this number.
expect(op, state)
Expectation value of the given operator op for the specified state.
state can either be a (density) operator or a ket.
source
QuantumInterface.variance — Function
variance(index, op, state)
If an index is given, it assumes that op is defined in the subsystem specified by this number
variance(op, state)
Variance of the given operator op for the specified state.
state can either be a (density) operator or a ket.
source
QuantumInterface.embed — Function
embed(basis1[, basis2], operators::Dict)
operators is a dictionary Dict{Vector{Int}, AbstractOperator}. The integer vector specifies in which subsystems the corresponding operator is defined.
embed(basis1[, basis2], indices::Vector, operators::Vector)
Tensor product of operators where missing indices are filled up with identity operators.
embed(basis1[, basis2], indices::Vector, op::AbstractOperator)
Embed operator acting on a joint Hilbert space where missing indices are filled up with identity operators.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
-           index::Integer, operator)
Embed an operator defined on a single subspace specified by the index into a SumBasis.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
-            indices, operator)
Embed an operator defined on multiple subspaces specified by the indices into a SumBasis.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
-           indices, operators)
Embed a list of operators on subspaces specified by the indices into a SumBasis.
source
QuantumInterface.permutesystems — Function
permutesystems(a, perm)
Change the ordering of the subsystems of the given object.
For a permutation vector [2,1,3] and a given object with basis [b1, b2, b3] this function results in [b2, b1, b3].
Base.exp — Method
exp(op::AbstractOperator)
Operator exponential.
  • Conversion of operators
SparseArrays.sparse — Method
sparse(op::AbstractOperator)
Convert an arbitrary operator into a sparse one.
See also: QuantumOpticsBase.SparseOperator
  • Time-dependent operators.
QuantumOpticsBase.current_time — Function
current_time(op::AbstractOperator)
Returns the current time of the operator op. If op is not time-dependent, this throws an ArgumentError.
source
QuantumOpticsBase.static_operator — Function
static_operator(op::AbstractOperator)
Returns a static (not time dependent) representation of op the current time. This strips the time-dependence and can be used to obtain a non-lazy matrix representation of the operator.
For example: sparse(static_operator(op(t)) return a sparse-matrix representation of op at time t.
source
QuantumOpticsBase.time_restrict — Function
time_restrict(op::TimeDependentSum, t_from, t_to)
-time_restrict(op::TimeDependentSum, t_to)
Restrict a TimeDependentSum op to the time window t_from <= t < t_to, forcing it to be exactly zero outside that range of times. If t_from is not provided, it is assumed to be zero. Return a new TimeDependentSum.
source
Exceptions
Quantum systems
Fock
QuantumInterface.FockBasis — Type
FockBasis(N,offset=0)
Basis for a Fock space where N specifies a cutoff, i.e. what the highest included fock state is. Similarly, the offset defines the lowest included fock state (default is 0). Note that the dimension of this basis is N+1-offset.
QuantumOpticsBase.destroy — Method
destroy([T=ComplexF64,] b::FockBasis)
Annihilation operator for the specified Fock space with optional data type T.
source
QuantumOpticsBase.create — Method
create([T=ComplexF64,] b::FockBasis)
Creation operator for the specified Fock space with optional data type T.
source
QuantumOpticsBase.displace — Function
displace([T=ComplexF64,] b::FockBasis, alpha)
Displacement operator $D(α)=\exp{\left(α\hat{a}^\dagger-α^*\hat{a}\right)}$ for the specified Fock space with optional data type T, computed as the matrix exponential of finite-dimensional (truncated) creation and annihilation operators.
source
QuantumOpticsBase.displace_analytical — Function
displace_analytical(alpha::Number, n::Integer, m::Integer)
Get a specific matrix element of the (analytical) displacement operator in the Fock basis: Dmn = ⟨n|D̂(α)|m⟩. The precision used for computation is based on the type of alpha. If alpha is a Float64, ComplexF64, or Int, the computation will be carried out at double precision.
source
displace_analytical(b::FockBasis, alpha::Number)
-displace_analytical(::Type{T}, b::FockBasis, alpha::Number)
Get the "analytical" displacement operator, whose matrix elements match (up to numerical imprecision) those of the exact infinite-dimensional displacement operator. This is different to the result of displace(..., alpha), which computes the matrix exponential exp(alpha * a' - conj(alpha) * a) using finite-dimensional (truncated) creation and annihilation operators a' and a.
source
QuantumOpticsBase.displace_analytical! — Function
displace_analytical!(op, alpha::Number)
Overwrite, in place, the matrix elements of the FockBasis operator op, so that it is equal to displace_analytical(eltype(op), basis(op), alpha)
source
QuantumOpticsBase.squeeze — Function
squeeze([T=ComplexF64,] b::SpinBasis, z)
Squeezing operator $S(z)=\exp{\left(\frac{z^*\hat{J_-}^2 - z\hat{J}_+}{2 N}\right)}$ for the  specified Spin-$N/2$ basis with optional data type T, computed as the matrix exponential. Too large squeezing ($|z| > \sqrt{N}$) will create an oversqueezed state.
source
squeeze([T=ComplexF64,] b::FockBasis, z)
Squeezing operator $S(z)=\exp{\left(\frac{z^*\hat{a}^2-z\hat{a}^{\dagger2}}{2}\right)}$ for the specified Fock space with optional data type T, computed as the matrix exponential of finite-dimensional (truncated) creation and annihilation operators.
source
Charge
QuantumOpticsBase.ChargeBasis — Type
ChargeBasis(ncut) <: Basis
Basis spanning -ncut, ..., ncut charge states, which are the fourier modes (irreducible representations) of a continuous U(1) degree of freedom, truncated at ncut.
The charge basis is a natural representation for circuit-QED elements such as the "transmon", which has a hamiltonian of the form
b = ChargeBasis(ncut)
-H = 4E_C * (n_g * identityoperator(b) + chargeop(b))^2 - E_J * cosφ(b)
with energies periodic in the charge offset n_g. See e.g. https://arxiv.org/abs/2005.12667.
source
QuantumOpticsBase.expiφ — Function
expiφ([T=ComplexF64,] b::ChargeBasis, k=1)
-expiφ([T=ComplexF64,] b::ShiftedChargeBasis, k=1)
Return operator $\exp(i k φ)$ for given ChargeBasis or ShiftedChargeBasis, representing the continous U(1) degree of freedom conjugate to the charge. This is a "shift" operator that shifts the charge by k.
source
QuantumOpticsBase.cosφ — Function
cosφ([T=ComplexF64,] b::ChargeBasis; k=1)
-cosφ([T=ComplexF64,] b::ShiftedChargeBasis; k=1)
Return operator $\cos(k φ)$ for given charge basis. See expiφ.
source
QuantumOpticsBase.sinφ — Function
sinφ([T=ComplexF64,] b::ChargeBasis; k=1)
-sinφ([T=ComplexF64,] b::ShiftedChargeBasis; k=1)
Return operator $\sin(k φ)$ for given charge basis. See expiφ.
source
N-level
QuantumOpticsBase.transition — Method
transition([T=ComplexF64,] b::NLevelBasis, to::Integer, from::Integer)
Transition operator $|\mathrm{to}⟩⟨\mathrm{from}|$.
source
Spin
QuantumInterface.SpinBasis — Type
SpinBasis(n)
Basis for spin-n particles.
The basis can be created for arbitrary spinnumbers by using a rational number, e.g. SpinBasis(3//2). The Pauli operators are defined for all possible spin numbers.
Particle
QuantumOpticsBase.PositionBasis — Type
PositionBasis(xmin, xmax, Npoints)
-PositionBasis(b::MomentumBasis)
Basis for a particle in real space.
For simplicity periodic boundaries are assumed which means that the rightmost point defined by xmax is not included in the basis but is defined to be the same as xmin.
When a MomentumBasis is given as argument the exact values of $x_{min}$ and $x_{max}$ are due to the periodic boundary conditions more or less arbitrary and are chosen to be $-\pi/dp$ and $\pi/dp$ with $dp=(p_{max}-p_{min})/N$.
source
QuantumOpticsBase.MomentumBasis — Type
MomentumBasis(pmin, pmax, Npoints)
-MomentumBasis(b::PositionBasis)
Basis for a particle in momentum space.
For simplicity periodic boundaries are assumed which means that pmax is not included in the basis but is defined to be the same as pmin.
When a PositionBasis is given as argument the exact values of $p_{min}$ and $p_{max}$ are due to the periodic boundary conditions more or less arbitrary and are chosen to be $-\pi/dx$ and $\pi/dx$ with $dx=(x_{max}-x_{min})/N$.
source
QuantumOpticsBase.spacing — Function
spacing(b::PositionBasis)
Difference between two adjacent points of the real space basis.
source
spacing(b::MomentumBasis)
Momentum difference between two adjacent points of the momentum basis.
source
Base.position — Method
position([T=ComplexF64,] b::PositionBasis)
Position operator in real space.
source
Base.position — Method
position([T=ComplexF64,] b:MomentumBasis)
Position operator in momentum space.
source
QuantumOpticsBase.potentialoperator — Function
potentialoperator([T=Float64,] b::PositionBasis, V(x))
Operator representing a potential $V(x)$ in real space.
source
potentialoperator([T=ComplexF64,] b::MomentumBasis, V(x))
Operator representing a potential $V(x)$ in momentum space.
source
potentialoperator([T=Float64,] b::CompositeBasis, V(x, y, z, ...))
Operator representing a potential $V$ in more than one dimension.
Arguments
  • b: Composite basis consisting purely either of PositionBasis or   MomentumBasis. Note, that calling this with a composite basis in   momentum space might consume a large amount of memory.
  • V: Function describing the potential. ATTENTION: The number of arguments   accepted by V must match the spatial dimension. Furthermore, the order   of the arguments has to match that of the order of the tensor product of   bases (e.g. if b=bx⊗by⊗bz, then V(x,y,z)).
source
QuantumOpticsBase.gaussianstate — Function
gaussianstate([T=ComplexF64,] b::PositionBasis, x0, p0, sigma)
+identityoperator(::Type{<:AbstractOperator}, ::Type{<:Number}, a::Basis[, b::Basis])
Return an identityoperator in the given bases. One can optionally specify the container type which has to a subtype of AbstractOperator as well as the number type to be used in the identity matrix.
QuantumOpticsBase.spre — Function
spre(op)
Create a super-operator equivalent for right side operator multiplication.
For operators $A$, $B$ the relation
\[    \mathrm{spre}(A) B = A B\]
holds. op can be a dense or a sparse operator.
source
QuantumOpticsBase.spost — Function
spost(op)
Create a super-operator equivalent for left side operator multiplication.
For operators $A$, $B$ the relation
\[    \mathrm{spost}(A) B = B A\]
holds. op can be a dense or a sparse operator.
source
QuantumOpticsBase.sprepost — Function
sprepost(op)
Create a super-operator equivalent for left and right side operator multiplication.
For operators $A$, $B$, $C$ the relation
\[    \mathrm{sprepost}(A, B) C = A C B\]
holds. A ond B can be dense or a sparse operators.
source
QuantumOpticsBase.liouvillian — Function
liouvillian(H, J; rates, Jdagger)
Create a super-operator equivalent to the master equation so that $\dot ρ = S ρ$.
The super-operator $S$ is defined by
\[S ρ = -\frac{i}{ħ} [H, ρ] + \sum_i J_i ρ J_i^† - \frac{1}{2} J_i^† J_i ρ - \frac{1}{2} ρ J_i^† J_i\]
Arguments
  • H: Hamiltonian.
  • J: Vector containing the jump operators.
  • rates: Vector or matrix specifying the coefficients for the jump operators.
  • Jdagger: Vector containing the hermitian conjugates of the jump operators. If they            are not given they are calculated automatically.
source
  • As far as it makes sense the same functions are implemented for bases, states, operators and superQuantumOpticsBase.
QuantumInterface.tensor — Function
tensor(x, y, z...)
Tensor product of the given objects. Alternatively, the unicode symbol ⊗ (\otimes) can be used.
LinearAlgebra.tr — Function
tr(x::AbstractOperator)
Trace of the given operator.
QuantumInterface.ptrace — Function
ptrace(a, indices)
Partial trace of the given basis, state or operator.
The indices argument, which can be a single integer or a vector of integers, specifies which subsystems are traced out. The number of indices has to be smaller than the number of subsystems, i.e. it is not allowed to perform a full trace.
LinearAlgebra.normalize! — Method
normalize!(x::StateVector)
In-place normalization of the given bra or ket so that norm(x) is one.
QuantumInterface.expect — Function
expect(index, op, state)
If an index is given, it assumes that op is defined in the subsystem specified by this number.
expect(op, state)
Expectation value of the given operator op for the specified state.
state can either be a (density) operator or a ket.
source
QuantumInterface.variance — Function
variance(index, op, state)
If an index is given, it assumes that op is defined in the subsystem specified by this number
variance(op, state)
Variance of the given operator op for the specified state.
state can either be a (density) operator or a ket.
source
QuantumInterface.embed — Function
embed(basis1[, basis2], operators::Dict)
operators is a dictionary Dict{Vector{Int}, AbstractOperator}. The integer vector specifies in which subsystems the corresponding operator is defined.
embed(basis1[, basis2], indices::Vector, operators::Vector)
Tensor product of operators where missing indices are filled up with identity operators.
embed(basis1[, basis2], indices::Vector, op::AbstractOperator)
Embed operator acting on a joint Hilbert space where missing indices are filled up with identity operators.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
+           index::Integer, operator)
Embed an operator defined on a single subspace specified by the index into a SumBasis.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
+            indices, operator)
Embed an operator defined on multiple subspaces specified by the indices into a SumBasis.
source
embed(basis_l::SumBasis, basis_r::SumBasis,
+           indices, operators)
Embed a list of operators on subspaces specified by the indices into a SumBasis.
source
QuantumInterface.permutesystems — Function
permutesystems(a, perm)
Change the ordering of the subsystems of the given object.
For a permutation vector [2,1,3] and a given object with basis [b1, b2, b3] this function results in [b2, b1, b3].
Base.exp — Method
exp(op::AbstractOperator)
Operator exponential.
  • Conversion of operators
SparseArrays.sparse — Method
sparse(op::AbstractOperator)
Convert an arbitrary operator into a sparse one.
See also: QuantumOpticsBase.SparseOperator
  • Time-dependent operators.
QuantumOpticsBase.current_time — Function
current_time(op::AbstractOperator)
Returns the current time of the operator op. If op is not time-dependent, this throws an ArgumentError.
source
QuantumOpticsBase.static_operator — Function
static_operator(op::AbstractOperator)
Returns a static (not time dependent) representation of op the current time. This strips the time-dependence and can be used to obtain a non-lazy matrix representation of the operator.
For example: sparse(static_operator(op(t)) return a sparse-matrix representation of op at time t.
source
QuantumOpticsBase.time_restrict — Function
time_restrict(op::TimeDependentSum, t_from, t_to)
+time_restrict(op::TimeDependentSum, t_to)
Restrict a TimeDependentSum op to the time window t_from <= t < t_to, forcing it to be exactly zero outside that range of times. If t_from is not provided, it is assumed to be zero. Return a new TimeDependentSum.
source
Exceptions
Quantum systems
Fock
QuantumInterface.FockBasis — Type
FockBasis(N,offset=0)
Basis for a Fock space where N specifies a cutoff, i.e. what the highest included fock state is. Similarly, the offset defines the lowest included fock state (default is 0). Note that the dimension of this basis is N+1-offset.
QuantumOpticsBase.destroy — Method
destroy([T=ComplexF64,] b::FockBasis)
Annihilation operator for the specified Fock space with optional data type T.
source
QuantumOpticsBase.create — Method
create([T=ComplexF64,] b::FockBasis)
Creation operator for the specified Fock space with optional data type T.
source
QuantumOpticsBase.displace — Function
displace([T=ComplexF64,] b::FockBasis, alpha)
Displacement operator $D(α)=\exp{\left(α\hat{a}^\dagger-α^*\hat{a}\right)}$ for the specified Fock space with optional data type T, computed as the matrix exponential of finite-dimensional (truncated) creation and annihilation operators.
source
QuantumOpticsBase.displace_analytical — Function
displace_analytical(alpha::Number, n::Integer, m::Integer)
Get a specific matrix element of the (analytical) displacement operator in the Fock basis: Dmn = ⟨n|D̂(α)|m⟩. The precision used for computation is based on the type of alpha. If alpha is a Float64, ComplexF64, or Int, the computation will be carried out at double precision.
source
displace_analytical(b::FockBasis, alpha::Number)
+displace_analytical(::Type{T}, b::FockBasis, alpha::Number)
Get the "analytical" displacement operator, whose matrix elements match (up to numerical imprecision) those of the exact infinite-dimensional displacement operator. This is different to the result of displace(..., alpha), which computes the matrix exponential exp(alpha * a' - conj(alpha) * a) using finite-dimensional (truncated) creation and annihilation operators a' and a.
source
QuantumOpticsBase.displace_analytical! — Function
displace_analytical!(op, alpha::Number)
Overwrite, in place, the matrix elements of the FockBasis operator op, so that it is equal to displace_analytical(eltype(op), basis(op), alpha)
source
QuantumOpticsBase.squeeze — Function
squeeze([T=ComplexF64,] b::SpinBasis, z)
Squeezing operator $S(z)=\exp{\left(\frac{z^*\hat{J_-}^2 - z\hat{J}_+}{2 N}\right)}$ for the  specified Spin-$N/2$ basis with optional data type T, computed as the matrix exponential. Too large squeezing ($|z| > \sqrt{N}$) will create an oversqueezed state.
source
squeeze([T=ComplexF64,] b::FockBasis, z)
Squeezing operator $S(z)=\exp{\left(\frac{z^*\hat{a}^2-z\hat{a}^{\dagger2}}{2}\right)}$ for the specified Fock space with optional data type T, computed as the matrix exponential of finite-dimensional (truncated) creation and annihilation operators.
source
Charge
QuantumOpticsBase.ChargeBasis — Type
ChargeBasis(ncut) <: Basis
Basis spanning -ncut, ..., ncut charge states, which are the fourier modes (irreducible representations) of a continuous U(1) degree of freedom, truncated at ncut.
The charge basis is a natural representation for circuit-QED elements such as the "transmon", which has a hamiltonian of the form
b = ChargeBasis(ncut)
+H = 4E_C * (n_g * identityoperator(b) + chargeop(b))^2 - E_J * cosφ(b)
with energies periodic in the charge offset n_g. See e.g. https://arxiv.org/abs/2005.12667.
source
QuantumOpticsBase.expiφ — Function
expiφ([T=ComplexF64,] b::ChargeBasis, k=1)
+expiφ([T=ComplexF64,] b::ShiftedChargeBasis, k=1)
Return operator $\exp(i k φ)$ for given ChargeBasis or ShiftedChargeBasis, representing the continous U(1) degree of freedom conjugate to the charge. This is a "shift" operator that shifts the charge by k.
source
QuantumOpticsBase.cosφ — Function
cosφ([T=ComplexF64,] b::ChargeBasis; k=1)
+cosφ([T=ComplexF64,] b::ShiftedChargeBasis; k=1)
Return operator $\cos(k φ)$ for given charge basis. See expiφ.
source
QuantumOpticsBase.sinφ — Function
sinφ([T=ComplexF64,] b::ChargeBasis; k=1)
+sinφ([T=ComplexF64,] b::ShiftedChargeBasis; k=1)
Return operator $\sin(k φ)$ for given charge basis. See expiφ.
source
N-level
QuantumOpticsBase.transition — Method
transition([T=ComplexF64,] b::NLevelBasis, to::Integer, from::Integer)
Transition operator $|\mathrm{to}⟩⟨\mathrm{from}|$.
source
Spin
QuantumInterface.SpinBasis — Type
SpinBasis(n)
Basis for spin-n particles.
The basis can be created for arbitrary spinnumbers by using a rational number, e.g. SpinBasis(3//2). The Pauli operators are defined for all possible spin numbers.
Particle
QuantumOpticsBase.PositionBasis — Type
PositionBasis(xmin, xmax, Npoints)
+PositionBasis(b::MomentumBasis)
Basis for a particle in real space.
For simplicity periodic boundaries are assumed which means that the rightmost point defined by xmax is not included in the basis but is defined to be the same as xmin.
When a MomentumBasis is given as argument the exact values of $x_{min}$ and $x_{max}$ are due to the periodic boundary conditions more or less arbitrary and are chosen to be $-\pi/dp$ and $\pi/dp$ with $dp=(p_{max}-p_{min})/N$.
source
QuantumOpticsBase.MomentumBasis — Type
MomentumBasis(pmin, pmax, Npoints)
+MomentumBasis(b::PositionBasis)
Basis for a particle in momentum space.
For simplicity periodic boundaries are assumed which means that pmax is not included in the basis but is defined to be the same as pmin.
When a PositionBasis is given as argument the exact values of $p_{min}$ and $p_{max}$ are due to the periodic boundary conditions more or less arbitrary and are chosen to be $-\pi/dx$ and $\pi/dx$ with $dx=(x_{max}-x_{min})/N$.
source
QuantumOpticsBase.spacing — Function
spacing(b::PositionBasis)
Difference between two adjacent points of the real space basis.
source
spacing(b::MomentumBasis)
Momentum difference between two adjacent points of the momentum basis.
source
Base.position — Method
position([T=ComplexF64,] b::PositionBasis)
Position operator in real space.
source
Base.position — Method
position([T=ComplexF64,] b:MomentumBasis)
Position operator in momentum space.
source
QuantumOpticsBase.potentialoperator — Function
potentialoperator([T=Float64,] b::PositionBasis, V(x))
Operator representing a potential $V(x)$ in real space.
source
potentialoperator([T=ComplexF64,] b::MomentumBasis, V(x))
Operator representing a potential $V(x)$ in momentum space.
source
potentialoperator([T=Float64,] b::CompositeBasis, V(x, y, z, ...))
Operator representing a potential $V$ in more than one dimension.
Arguments
  • b: Composite basis consisting purely either of PositionBasis or   MomentumBasis. Note, that calling this with a composite basis in   momentum space might consume a large amount of memory.
  • V: Function describing the potential. ATTENTION: The number of arguments   accepted by V must match the spatial dimension. Furthermore, the order   of the arguments has to match that of the order of the tensor product of   bases (e.g. if b=bx⊗by⊗bz, then V(x,y,z)).
source
QuantumOpticsBase.gaussianstate — Function
gaussianstate([T=ComplexF64,] b::PositionBasis, x0, p0, sigma)
 gaussianstate([T=ComplexF64,] b::MomentumBasis, x0, p0, sigma)
Create a Gaussian state around x0 andp0 with width sigma.
In real space the gaussian state is defined as
\[\Psi(x) = \frac{1}{\pi^{1/4}\sqrt{\sigma}}
             e^{i p_0 (x-\frac{x_0}{2}) - \frac{(x-x_0)^2}{2 \sigma^2}}\]
and is connected to the momentum space definition
\[\Psi(p) = \frac{\sqrt{\sigma}}{\pi^{1/4}}
             e^{-i x_0 (p-\frac{p_0}{2}) - \frac{1}{2}(p-p_0)^2 \sigma^2}\]
via a Fourier-transformation
\[\Psi(p) = \frac{1}{\sqrt{2\pi}}
-            \int_{-\infty}^{\infty} e^{-ipx}\Psi(x) \mathrm{d}x\]
The state has the properties
  • $⟨p⟩ = p_0$
  • $⟨x⟩ = x_0$
  • $\mathrm{Var}(x) = \frac{σ^2}{2}$
  • $\mathrm{Var}(p) = \frac{1}{2 σ^2}$
Due to the numerically necessary discretization additional scaling factors $\sqrt{Δx}$ and $\sqrt{Δp}$ are used so that $\langle x_i|Ψ\rangle = \sqrt{Δ x} Ψ(x_i)$ and $\langle p_i|Ψ\rangle = \sqrt{Δ p} Ψ(p_i)$ so that the resulting Ket state is normalized.
source
QuantumOpticsBase.FFTKets — Type
FFTKets
Operator that can only perform fast fourier transformations on Kets. This is much more memory efficient when only working with Kets.
source
QuantumOpticsBase.transform — Function
transform(b1::MomentumBasis, b2::PositionBasis)
-transform(b1::PositionBasis, b2::MomentumBasis)
Transformation operator between position basis and momentum basis.
source
transform(b1::CompositeBasis, b2::CompositeBasis)
Transformation operator between two composite bases. Each of the bases has to contain bases of type PositionBasis and the other one a corresponding MomentumBasis.
source
transform([S=ComplexF64, ]b1::PositionBasis, b2::FockBasis; x0=1)
+            \int_{-\infty}^{\infty} e^{-ipx}\Psi(x) \mathrm{d}x\]
The state has the properties
  • $⟨p⟩ = p_0$
  • $⟨x⟩ = x_0$
  • $\mathrm{Var}(x) = \frac{σ^2}{2}$
  • $\mathrm{Var}(p) = \frac{1}{2 σ^2}$
Due to the numerically necessary discretization additional scaling factors $\sqrt{Δx}$ and $\sqrt{Δp}$ are used so that $\langle x_i|Ψ\rangle = \sqrt{Δ x} Ψ(x_i)$ and $\langle p_i|Ψ\rangle = \sqrt{Δ p} Ψ(p_i)$ so that the resulting Ket state is normalized.
source
QuantumOpticsBase.FFTKets — Type
FFTKets
Operator that can only perform fast fourier transformations on Kets. This is much more memory efficient when only working with Kets.
source
QuantumOpticsBase.transform — Function
transform(b1::MomentumBasis, b2::PositionBasis)
+transform(b1::PositionBasis, b2::MomentumBasis)
Transformation operator between position basis and momentum basis.
source
transform(b1::CompositeBasis, b2::CompositeBasis)
Transformation operator between two composite bases. Each of the bases has to contain bases of type PositionBasis and the other one a corresponding MomentumBasis.
source
transform([S=ComplexF64, ]b1::PositionBasis, b2::FockBasis; x0=1)
 transform([S=ComplexF64, ]b1::FockBasis, b2::PositionBasis; x0=1)
Transformation operator between position basis and fock basis.
The coefficients are connected via the relation
\[ψ(x_i) = \sum_{n=0}^N ⟨x_i|n⟩ ψ_n\]
where $⟨x_i|n⟩$ is the value of the n-th eigenstate of a particle in a harmonic trap potential at position $x$, i.e.:
\[⟨x_i|n⟩ = π^{-\frac{1}{4}} \frac{e^{-\frac{1}{2}\left(\frac{x}{x_0}\right)^2}}{\sqrt{x_0}}
-            \frac{1}{\sqrt{2^n n!}} H_n\left(\frac{x}{x_0}\right)\]
source
Subspace bases
Many-body
QuantumOpticsBase.ManyBodyBasis — Type
ManyBodyBasis(b, occupations)
Basis for a many body system.
The basis has to know the associated one-body basis b and which occupation states should be included. The occupations_hash is used to speed up checking if two many-body bases are equal.
source
QuantumOpticsBase.fermionstates — Function
fermionstates([T, ]Nmodes, Nparticles)
-fermionstates([T, ]b, Nparticles)
Generate all fermionic occupation states for N-particles in M-modes. Nparticles can be a vector to define a Hilbert space with variable particle number. T is the type of the occupation states - default is OccupationNumbers{FermionStatistics,Int}, but can be any occupations type.
source
QuantumOpticsBase.bosonstates — Function
bosonstates([T, ]Nmodes, Nparticles)
-bosonstates([T, ]b, Nparticles)
Generate all bosonic occupation states for N-particles in M-modes. Nparticles can be a vector to define a Hilbert space with variable particle number. T is the type of the occupation states - default is OccupationNumbers{BosonStatistics,Int}, but can be any occupations type.
source
QuantumOpticsBase.number — Method
number([T=ComplexF64,] mb::ManyBodyBasis, index)
Particle number operator for the i-th mode of the many-body basis b.
source
QuantumOpticsBase.destroy — Method
destroy([T=ComplexF64,] mb::ManyBodyBasis, index)
Annihilation operator for the i-th mode of the many-body basis b.
source
QuantumOpticsBase.create — Method
create([T=ComplexF64,] mb::ManyBodyBasis, index)
Creation operator for the i-th mode of the many-body basis b.
source
QuantumOpticsBase.transition — Method
transition([T=ComplexF64,] mb::ManyBodyBasis, to, from)
Operator $|\mathrm{to}⟩⟨\mathrm{from}|$ transferring particles between modes.
Note that to and from can be collections of indices. The resulting operator in this case will be equal to $\ldots a^\dagger_{to_2} a^\dagger_{to_1} \ldots a_{from_2} a_{from_1}$.
source
QuantumOpticsBase.manybodyoperator — Function
manybodyoperator(mb::ManyBodyBasis, op)
Create the many-body operator from the given one-body operator op.
The given operator can either be a one-body operator or a two-body interaction. Higher order interactions are at the moment not implemented.
The mathematical formalism for the one-body case is described by
\[X = \sum_{ij} a_i^† a_j ⟨u_i| x | u_j⟩\]
and for the interaction case by
\[X = \sum_{ijkl} a_i^† a_j^† a_k a_l ⟨u_i|⟨u_j| x |u_k⟩|u_l⟩\]
where $X$ is the N-particle operator, $x$ is the one-body operator and $|u⟩$ are the one-body states associated to the different modes of the N-particle basis.
source
Direct sum
QuantumInterface.directsum — Function
directsum(b1::Basis, b2::Basis)
Construct the SumBasis out of two sub-bases.
directsum(x::Ket, y::Ket)
Construct a spinor via the directsum of two Kets. The result is a Ket with data given by [x.data;y.data] and its basis given by the corresponding SumBasis. NOTE: The resulting state is not normalized!
source
directsum(x::DataOperator, y::DataOperator)
Compute the direct sum of two operators. The result is an operator on the corresponding SumBasis.
source
QuantumOpticsBase.getblock — Function
getblock(x::Ket{<:SumBasis}, i)
For a Ket defined on a SumBasis, get the state as it is defined on the ith sub-basis.
source
getblock(op::Operator{<:SumBasis,<:SumBasis}, i, j)
Get the sub-basis operator corresponding to the block (i,j) of op.
source
QuantumOpticsBase.setblock! — Function
setblock!(x::Ket{<:SumBasis}, val::Ket, i)
Set the data of x on the ith sub-basis equal to the data of val.
source
setblock!(op::DataOperator{<:SumBasis,<:SumBasis}, val::DataOperator, i, j)
Set the data of op corresponding to the block (i,j) equal to the data of val.
source
Metrics
QuantumOpticsBase.tracenorm_h — Function
tracenorm_h(rho)
Trace norm of rho.
It uses the identity
\[T(ρ) = Tr\{\sqrt{ρ^† ρ}\} = \sum_i |λ_i|\]
where $λ_i$ are the eigenvalues of rho.
source
QuantumOpticsBase.tracenorm_nh — Function
tracenorm_nh(rho)
Trace norm of rho.
Note that in this case rho doesn't have to be represented by a square matrix (i.e. it can have different left-hand and right-hand bases).
It uses the identity
\[    T(ρ) = Tr\{\sqrt{ρ^† ρ}\} = \sum_i σ_i\]
where $σ_i$ are the singular values of rho.
source
QuantumOpticsBase.tracedistance_h — Function
tracedistance_h(rho, sigma)
Trace distance between rho and sigma.
It uses the identity
\[T(ρ,σ) = \frac{1}{2} Tr\{\sqrt{(ρ - σ)^† (ρ - σ)}\} = \frac{1}{2} \sum_i |λ_i|\]
where $λ_i$ are the eigenvalues of rho - sigma.
source
QuantumOpticsBase.tracedistance_nh — Function
tracedistance_nh(rho, sigma)
Trace distance between rho and sigma.
Note that in this case rho and sigma don't have to be represented by square matrices (i.e. they can have different left-hand and right-hand bases).
It uses the identity
\[    T(ρ,σ) = \frac{1}{2} Tr\{\sqrt{(ρ - σ)^† (ρ - σ)}\}
-         = \frac{1}{2} \sum_i σ_i\]
where $σ_i$ are the singular values of rho - sigma.
source
QuantumOpticsBase.entropy_vn — Function
entropy_vn(rho)
Von Neumann entropy of a density matrix.
The Von Neumann entropy of a density operator is defined as
\[S(ρ) = -Tr(ρ \log(ρ)) = -\sum_n λ_n\log(λ_n)\]
where $λ_n$ are the eigenvalues of the density matrix $ρ$, $\log$ is the natural logarithm and $0\log(0) ≡ 0$.
Arguments
  • rho: Density operator of which to calculate Von Neumann entropy.
  • tol=1e-15: Tolerance for rounding errors in the computed eigenvalues.
source
QuantumOpticsBase.entropy_renyi — Function
entropy_renyi(rho, α::Integer=2)
Renyi α-entropy of a density matrix, where r α≥0, α≂̸1.
The Renyi α-entropy of a density operator is defined as
\[S_α(ρ) = 1/(1-α) \log(Tr(ρ^α))\]
source
QuantumOpticsBase.fidelity — Function
fidelity(rho, sigma)
Fidelity of two density operators.
The fidelity of two density operators $ρ$ and $σ$ is defined by
\[F(ρ, σ) = Tr\left(\sqrt{\sqrt{ρ}σ\sqrt{ρ}}\right),\]
where $\sqrt{ρ}=\sum_n\sqrt{λ_n}|ψ⟩⟨ψ|$.
source
QuantumOpticsBase.ptranspose — Function
ptranspose(rho, indices)
Partial transpose of rho with respect to subsystem specified by indices. 
The indices argument can be a single integer or a collection of integers.
source
QuantumOpticsBase.negativity — Function
negativity(rho, index)
Negativity of rho with respect to subsystem index.
The negativity of a density matrix ρ is defined as
\[N(ρ) = \frac{\|ρᵀ\|-1}{2},\]
where ρᵀ is the partial transpose.
source
QuantumOpticsBase.entanglement_entropy — Function
entanglement_entropy(state, partition, [entropy_fun=entropy_vn])
Computes the entanglement entropy of state between the list of sites partition and the rest of the system. The state must be defined in a composite basis.
If state isa AbstractOperator the operator-space entanglement entropy is computed, which has the property
entanglement_entropy(dm(ket)) = 2 * entanglement_entropy(ket)
By default the computed entropy is the Von-Neumann entropy, but a different function can be provided (for example to compute the entanglement-renyi entropy).
source
State definitions
QuantumOpticsBase.passive_state — Function
passive_state(rho,IncreasingEigenenergies=true)
Passive state $π$ of $ρ$. IncreasingEigenenergies=true means that higher indices correspond to higher energies.
source
Pauli
QuantumInterface.PauliBasis — Type
PauliBasis(num_qubits::Int)
Basis for an N-qubit space where num_qubits specifies the number of qubits. The dimension of the basis is 2²ᴺ.
Printing
QuantumOpticsBase.set_printing — Function
QuantumOptics.set_printing(; standard_order, rounding_tol)
Set options for REPL output.
Arguments
  • standard_order=false: For performance reasons, the order of the tensor   product is inverted, i.e. tensor(a, b)=kron(b, a). When changing this   to true, the output shown in the REPL will exhibit the correct order.
  • rounding_tol=1e-17: Tolerance for floating point errors shown in the output.
source
LazyTensor functions
QuantumOpticsBase.lazytensor_enable_cache — Function
lazytensor_enable_cache(; maxsize::Int = ..., maxrelsize::Real = ...)
(Re)-enable the cache for further use; set the maximal size maxsize (as number of bytes) or relative size maxrelsize, as a fraction between 0 and 1, resulting in maxsize = floor(Int, maxrelsize * Sys.total_memory()). Default value is maxsize = 2^32 bytes, which amounts to 4 gigabytes of memory.
source

+            \frac{1}{\sqrt{2^n n!}} H_n\left(\frac{x}{x_0}\right)\]
source

Subspace bases

Many-body

QuantumOpticsBase.ManyBodyBasis — Type
ManyBodyBasis(b, occupations)

Basis for a many body system.

The basis has to know the associated one-body basis b and which occupation states should be included. The occupations_hash is used to speed up checking if two many-body bases are equal.

source
QuantumOpticsBase.fermionstates — Function
fermionstates([T, ]Nmodes, Nparticles)
+fermionstates([T, ]b, Nparticles)

Generate all fermionic occupation states for N-particles in M-modes. Nparticles can be a vector to define a Hilbert space with variable particle number. T is the type of the occupation states - default is OccupationNumbers{FermionStatistics,Int}, but can be any occupations type.

source
QuantumOpticsBase.bosonstates — Function
bosonstates([T, ]Nmodes, Nparticles)
+bosonstates([T, ]b, Nparticles)

Generate all bosonic occupation states for N-particles in M-modes. Nparticles can be a vector to define a Hilbert space with variable particle number. T is the type of the occupation states - default is OccupationNumbers{BosonStatistics,Int}, but can be any occupations type.

source
QuantumOpticsBase.number — Method
number([T=ComplexF64,] mb::ManyBodyBasis, index)

Particle number operator for the i-th mode of the many-body basis b.

source
QuantumOpticsBase.destroy — Method
destroy([T=ComplexF64,] mb::ManyBodyBasis, index)

Annihilation operator for the i-th mode of the many-body basis b.

source
QuantumOpticsBase.create — Method
create([T=ComplexF64,] mb::ManyBodyBasis, index)

Creation operator for the i-th mode of the many-body basis b.

source
QuantumOpticsBase.transition — Method
transition([T=ComplexF64,] mb::ManyBodyBasis, to, from)

Operator $|\mathrm{to}⟩⟨\mathrm{from}|$ transferring particles between modes.

Note that to and from can be collections of indices. The resulting operator in this case will be equal to $\ldots a^\dagger_{to_2} a^\dagger_{to_1} \ldots a_{from_2} a_{from_1}$.

source
QuantumOpticsBase.manybodyoperator — Function
manybodyoperator(mb::ManyBodyBasis, op)

Create the many-body operator from the given one-body operator op.

The given operator can either be a one-body operator or a two-body interaction. Higher order interactions are at the moment not implemented.

The mathematical formalism for the one-body case is described by

\[X = \sum_{ij} a_i^† a_j ⟨u_i| x | u_j⟩\]

and for the interaction case by

\[X = \sum_{ijkl} a_i^† a_j^† a_k a_l ⟨u_i|⟨u_j| x |u_k⟩|u_l⟩\]

where $X$ is the N-particle operator, $x$ is the one-body operator and $|u⟩$ are the one-body states associated to the different modes of the N-particle basis.

source

Direct sum

QuantumInterface.directsum — Function
directsum(b1::Basis, b2::Basis)

Construct the SumBasis out of two sub-bases.

directsum(x::Ket, y::Ket)

Construct a spinor via the directsum of two Kets. The result is a Ket with data given by [x.data;y.data] and its basis given by the corresponding SumBasis. NOTE: The resulting state is not normalized!

source
directsum(x::DataOperator, y::DataOperator)

Compute the direct sum of two operators. The result is an operator on the corresponding SumBasis.

source
QuantumOpticsBase.getblock — Function
getblock(x::Ket{<:SumBasis}, i)

For a Ket defined on a SumBasis, get the state as it is defined on the ith sub-basis.

source
getblock(op::Operator{<:SumBasis,<:SumBasis}, i, j)

Get the sub-basis operator corresponding to the block (i,j) of op.

source
QuantumOpticsBase.setblock! — Function
setblock!(x::Ket{<:SumBasis}, val::Ket, i)

Set the data of x on the ith sub-basis equal to the data of val.

source
setblock!(op::DataOperator{<:SumBasis,<:SumBasis}, val::DataOperator, i, j)

Set the data of op corresponding to the block (i,j) equal to the data of val.

source

Metrics

QuantumOpticsBase.tracenorm_h — Function
tracenorm_h(rho)

Trace norm of rho.

It uses the identity

\[T(ρ) = Tr\{\sqrt{ρ^† ρ}\} = \sum_i |λ_i|\]

where $λ_i$ are the eigenvalues of rho.

source
QuantumOpticsBase.tracenorm_nh — Function
tracenorm_nh(rho)

Trace norm of rho.

Note that in this case rho doesn't have to be represented by a square matrix (i.e. it can have different left-hand and right-hand bases).

It uses the identity

\[ T(ρ) = Tr\{\sqrt{ρ^† ρ}\} = \sum_i σ_i\]

where $σ_i$ are the singular values of rho.

source
QuantumOpticsBase.tracedistance_h — Function
tracedistance_h(rho, sigma)

Trace distance between rho and sigma.

It uses the identity

\[T(ρ,σ) = \frac{1}{2} Tr\{\sqrt{(ρ - σ)^† (ρ - σ)}\} = \frac{1}{2} \sum_i |λ_i|\]

where $λ_i$ are the eigenvalues of rho - sigma.

source
QuantumOpticsBase.tracedistance_nh — Function
tracedistance_nh(rho, sigma)

Trace distance between rho and sigma.

Note that in this case rho and sigma don't have to be represented by square matrices (i.e. they can have different left-hand and right-hand bases).

It uses the identity

\[ T(ρ,σ) = \frac{1}{2} Tr\{\sqrt{(ρ - σ)^† (ρ - σ)}\} + = \frac{1}{2} \sum_i σ_i\]

where $σ_i$ are the singular values of rho - sigma.

source
QuantumOpticsBase.entropy_vn — Function
entropy_vn(rho)

Von Neumann entropy of a density matrix.

The Von Neumann entropy of a density operator is defined as

\[S(ρ) = -Tr(ρ \log(ρ)) = -\sum_n λ_n\log(λ_n)\]

where $λ_n$ are the eigenvalues of the density matrix $ρ$, $\log$ is the natural logarithm and $0\log(0) ≡ 0$.

Arguments

  • rho: Density operator of which to calculate Von Neumann entropy.
  • tol=1e-15: Tolerance for rounding errors in the computed eigenvalues.
source
QuantumOpticsBase.entropy_renyi — Function
entropy_renyi(rho, α::Integer=2)

Renyi α-entropy of a density matrix, where r α≥0, α≂̸1.

The Renyi α-entropy of a density operator is defined as

\[S_α(ρ) = 1/(1-α) \log(Tr(ρ^α))\]

source
QuantumOpticsBase.fidelity — Function
fidelity(rho, sigma)

Fidelity of two density operators.

The fidelity of two density operators $ρ$ and $σ$ is defined by

\[F(ρ, σ) = Tr\left(\sqrt{\sqrt{ρ}σ\sqrt{ρ}}\right),\]

where $\sqrt{ρ}=\sum_n\sqrt{λ_n}|ψ⟩⟨ψ|$.

source
QuantumOpticsBase.ptranspose — Function
ptranspose(rho, indices)

Partial transpose of rho with respect to subsystem specified by indices.

The indices argument can be a single integer or a collection of integers.

source
QuantumOpticsBase.negativity — Function
negativity(rho, index)

Negativity of rho with respect to subsystem index.

The negativity of a density matrix ρ is defined as

\[N(ρ) = \frac{\|ρᵀ\|-1}{2},\]

where ρᵀ is the partial transpose.

source
QuantumOpticsBase.entanglement_entropy — Function
entanglement_entropy(state, partition, [entropy_fun=entropy_vn])

Computes the entanglement entropy of state between the list of sites partition and the rest of the system. The state must be defined in a composite basis.

If state isa AbstractOperator the operator-space entanglement entropy is computed, which has the property

entanglement_entropy(dm(ket)) = 2 * entanglement_entropy(ket)

By default the computed entropy is the Von-Neumann entropy, but a different function can be provided (for example to compute the entanglement-renyi entropy).

source

State definitions

QuantumOpticsBase.passive_state — Function
passive_state(rho,IncreasingEigenenergies=true)

Passive state $π$ of $ρ$. IncreasingEigenenergies=true means that higher indices correspond to higher energies.

source

Pauli

QuantumInterface.PauliBasis — Type
PauliBasis(num_qubits::Int)

Basis for an N-qubit space where num_qubits specifies the number of qubits. The dimension of the basis is 2²ᴺ.

Printing

QuantumOpticsBase.set_printing — Function
QuantumOptics.set_printing(; standard_order, rounding_tol)

Set options for REPL output.

Arguments

  • standard_order=false: For performance reasons, the order of the tensor product is inverted, i.e. tensor(a, b)=kron(b, a). When changing this to true, the output shown in the REPL will exhibit the correct order.
  • rounding_tol=1e-17: Tolerance for floating point errors shown in the output.
source

LazyTensor functions

QuantumOpticsBase.lazytensor_enable_cache — Function
lazytensor_enable_cache(; maxsize::Int = ..., maxrelsize::Real = ...)

(Re)-enable the cache for further use; set the maximal size maxsize (as number of bytes) or relative size maxrelsize, as a fraction between 0 and 1, resulting in maxsize = floor(Int, maxrelsize * Sys.total_memory()). Default value is maxsize = 2^32 bytes, which amounts to 4 gigabytes of memory.

source
diff --git a/dev/index.html b/dev/index.html index 4a0850f..33d7ca8 100644 --- a/dev/index.html +++ b/dev/index.html @@ -1,2 +1,2 @@ -Introduction · QuantumOpticsBase.jl
Edit on GitHub

Introduction

The documentation found here is just the lightweight version of the full docs. It lists all types and functions as well as their API included in the QuantumOpticsBase.jl module. The full documentation of QuantumOptics.jl can be found here.

+Introduction · QuantumOpticsBase.jl
Edit on GitHub

Introduction

The documentation found here is just the lightweight version of the full docs. It lists all types and functions as well as their API included in the QuantumOpticsBase.jl module. The full documentation of QuantumOptics.jl can be found here.

diff --git a/dev/search/index.html b/dev/search/index.html index 8c5e4bb..43edd84 100644 --- a/dev/search/index.html +++ b/dev/search/index.html @@ -1,2 +1,2 @@ -Search · QuantumOpticsBase.jl

Loading search...

    +Search · QuantumOpticsBase.jl

    Loading search...