Quantum operators

LaTeX{SP, SB}(body, spdelimiter::String=", ", sbdelimiter::String=", "; options...) where {SP, SB}

LaTeX string representation of quantum operators.

LinearFunction{O<:Union{Union{}, OperatorPack}, F<:Function} <: LinearTransformation

Wrapper a function to be a linear transformation.

LinearTransformation <: Function

Abstract linear transformation on quantum operators.

(transformation::LinearTransformation)(ms::OperatorSet; kwargs...) -> OperatorSet

Get the linear transformed quantum operators.

Matrixization <: LinearTransformation

Matrixization transformation.

Operator{V, I<:ZeroAtLeast{OperatorIndex}} <: OperatorProd{V, I}

Operator.

OperatorIndex <: QuantumOperator

An operator index is the irreducible symbolic unit to completely represent a quantum operator.

It plays the role of the symbols as in usual computer algebras while it can host internal structures, which is convenient to represent quantum operators with complicated spatial and/or internal degrees of freedom.

OperatorPack{V, I} <: QuantumOperator

Entity that represent the pack of a number and an id of a quantum operator.

Basically, a concrete subtype should contain two predefined contents:

• value::V: the coefficient of the pack
• id::I: the id of the pack

OperatorProd{V, I<:Tuple} <: OperatorPack{V, I}

A special kind of OperatorPack, where the relation between the coefficient and each component of the operator id can be viewed as product.

OperatorSet{M<:OperatorPack} <: QuantumOperator

Set of OperatorPacks.

1. The relation between two OperatorPacks in an OperatorSet can be viewed as addition.
2. But in general, only iteration over OperatorPacks and length are supported.
3. To use arithmetic operations, please refer to its subtype, OperatorSum.

OperatorSum{M<:OperatorPack, I} <: OperatorSet{M}

Sum of OperatorPacks.

Similar items are automatically merged with the aid of the id system.

OperatorSum(ms)
OperatorSum(ms::QuantumOperator...)
OperatorSum{M}(ms) where {M<:OperatorPack}
OperatorSum{M}(ms::QuantumOperator...) where {M<:OperatorPack}

Get the sum of OperatorPacks.

Operators{O<:Operator, I<:ZeroAtLeast{OperatorIndex}}

A set of operators.

Type alias for OperatorSum{O<:Operator, I<:ZeroAtLeast{OperatorIndex}}.

Operators(opts::Operator...)
Operators{M}(opts::Operator...)

Get a set of operators.

Permutation{T} <: LinearTransformation

Permutation transformation.

(permutation::Permutation)(m::OperatorProd; rev::Bool=false, kwargs...) -> OperatorSum

Permute the operator units of an OperatorProd to the descending order according to the table contained in permutation.

permute(u₁::OperatorIndex, u₂::OperatorIndex) -> Union{OperatorProd, OperatorSum}

QuantumOperator

Abstract type of any quantum operator.

TabledUnitSubstitution{U<:OperatorIndex, S<:OperatorSum, T<:AbstractDict{U, S}} <: UnitSubstitution{U, S}

A concrete unit substitution transformation, which stores every substitution of the old OperatorIndexs in its table as a dictionary.

UnitSubstitution{U<:OperatorIndex, S<:OperatorSum} <: LinearTransformation

Unit substitution transformation, which substitutes each OperatorIndex in the old quantum operators to a new expression represented by an OperatorSum.

(unitsubstitution::UnitSubstitution)(m::OperatorProd; kwargs...) -> OperatorSum

Substitute every OperatorIndex in an OperatorProd with a new OperatorSum.

ZeroAtLeast(::Type{U}, attrs::Vararg{NTuple{N}, M}) where {U<:OperatorIndex, N, M}

Get the composite id from the components of singular ids.

*(factor::Number, m::OperatorIndex) -> Operator
*(m::OperatorIndex, factor::Number) -> Operator
*(m₁::OperatorIndex, m₂::OperatorIndex) -> Operator
*(factor::Number, m::OperatorPack) -> OperatorPack
*(m::OperatorPack, factor::Number) -> OperatorPack
*(m₁::OperatorPack, m₂::OperatorIndex) -> OperatorPack
*(m₁::OperatorIndex, m₁::OperatorPack) -> OperatorPack
*(m₁::OperatorPack, m₂::OperatorPack) -> OperatorPack
*(factor::Number, ms::OperatorSum) -> OperatorSum
*(ms::OperatorSum, factor::Number) -> OperatorSum
*(m::OperatorIndex, ms::OperatorSum) -> OperatorSum
*(ms::OperatorSum, m::OperatorIndex) -> OperatorSum
*(m::OperatorPack, ms::OperatorSum) -> OperatorSum
*(ms::OperatorSum, m::OperatorPack) -> OperatorSum
*(ms₁::OperatorSum, ms₂::OperatorSum) -> OperatorSum

Overloaded * between quantum operators or a quantum operator and a number.

+(m::QuantumOperator) -> typeof(m)
+(m₁::QuantumOperator, m₂::QuantumOperator) -> OperatorSum
+(factor::Number, m::QuantumOperator) -> OperatorSum
+(m::QuantumOperator, factor::Number) -> OperatorSum

Overloaded + between quantum operators.

-(m::QuantumOperator) -> QuantumOperator
-(m₁::QuantumOperator, m₂::QuantumOperator) -> OperatorSum
-(factor::Number, m::QuantumOperator) -> OperatorSum
-(m::QuantumOperator, factor::Number) -> OperatorSum

Overloaded - between quantum operators.

/(m::QuantumOperator, factor::Number) -> QuantumOperator

Overloaded / between a quantum operator and a number.

//(m::QuantumOperator, factor::Number) -> QuantumOperator

Overloaded // between a quantum operator and a number.

^(m::QuantumOperator, n::Integer) -> QuantumOperator

Overloaded ^ between a quantum operator and an integer.

adjoint(id::ZeroAtLeast{OperatorIndex}) -> ZeroAtLeast{OperatorIndex}

Get the adjoint of an id.

adjoint(opts::Operators) -> Operators

Get the adjoint of a set of operators.

adjoint(m::Operator) -> Operator

Get the adjoint of an operator.

conj(m::OperatorIndex) -> OperatorIndex
conj(m::OperatorPack) -> OperatorPack
conj(m::OperatorSum) -> OperatorSum

Get the conjugation.

convert(::Type{M}, m::Number) where {M<:OperatorProd}

Convert a number to a quantum operator.

convert(::Type{M}, u::OperatorIndex) where {M<:Operator}

Convert an operator index to an operator.

convert(::Type{M}, m::OperatorPack) where {M<:OperatorPack}

Convert a quantum operator from one type to another.

eltype(m::OperatorProd)
eltype(::Type{M}) where {M<:OperatorProd}

Get the eltype of an OperatorProd.

eltype(ms::OperatorSet)
eltype(::Type{<:OperatorSet{M}}) where {M<:OperatorPack}

Get the eltype of an OperatorSet.

empty(ms::OperatorSum) -> typeof(ms)
empty!(ms::OperatorSum) -> typeof(ms)

Get an empty copy or empty an OperatorSum.

getindex(m::OperatorProd, i::Integer) -> eltype(idtype(m))
getindex(m::OperatorProd, slice) -> OperatorProd

Overloaded [].

getindex(ms::OperatorSum, index::Integer) -> eltype(ms)
getindex(ms::OperatorSum, indexes::AbstractVector{<:Integer}) -> typeof(ms)
getindex(ms::OperatorSum, ::Colon) -> typeof(ms)

Overloaded [].

getproperty(id::ZeroAtLeast{OperatorIndex}, name::Symbol)

Get the property of a composite id.

haskey(ms::OperatorSum, id) -> Bool

Judge whether an OperatorSum contains an OperatorPack with the given id.

isapprox(m₁::OperatorPack, m₂::OperatorPack; atol::Real=atol, rtol::Real=rtol) -> Bool

Compare two OperatorPacks and judge whether they are approximate to each other.

isapprox(ms₁::OperatorSum, ms₂::OperatorSum; atol::Real=atol, rtol::Real=rtol) -> Bool

Compare two OperatorSums and judge whether they are approximate to each other.

iszero(u::OperatorIndex) -> Bool

Judge whether an OperatorIndex is zero, which is defined to be always false.

iszero(m::OperatorPack) -> Bool

Judge whether an OperatorPack is zero, i.e., its value is zero.

iszero(ms::OperatorSet) -> Bool

Judge whether an OperatorSet is zero, i.e, it does not contain any OperatorPack.

iszero(ms::OperatorSum) -> Bool

Judge whether an OperatorSum is zero, i.e, it does not contain any OperatorPack.

iterate(m::OperatorProd)
iterate(m::OperatorProd, state)

Iterate over the components of the id of an OperatorProd.

iterate(ms::OperatorSum)
iterate(ms::OperatorSum, state)

Iterate over the OperatorPacks contained in an OperatorSum.

length(m::OperatorProd) -> Int

Get the length of an OperatorProd.

length(ms::OperatorSum) -> Int

Get the number of OperatorPacks contained in an OperatorSum.

map!(f::Function, ms::OperatorSum; kwargs...) -> typeof(ms)

In place map of an OperatorSum by the function f elementally.

one(::Type{M}) where {M<:OperatorProd}
one(m::OperatorProd)

Get the identity quantum operator.

propertynames(::Type{I}) where I<:ZeroAtLeast{OperatorIndex} -> ZeroAtLeast{Symbol}

Get the property names of a composite id.

replace(m::OperatorPack, v) -> OperatorPack

Replace the value of an OperatorPack.

show(io::IO, ::MIME"text/latex", op::QuantumOperator)
show(io::IO, m::MIME"text/latex", ops::OneAtLeast{<:QuantumOperator})
show(io::IO, ::MIME"text/latex", ops::AbstractVector{<:QuantumOperator})
show(io::IO, ::MIME"text/latex", ops::AbstractMatrix{<:QuantumOperator})

Show a quantum operator.

split(m::OperatorProd) -> Tuple{valtype(m), Vararg{Any}}

Split an OperatorProd into the coefficient and a sequence of the components of its id.

valtype(m::OperatorPack)
valtype(::Type{T}) where {T<:OperatorPack}

Get the type of the value of an OperatorPack.

zero(m::QuantumOperator)

Get a zero QuantumOperator.

zero(::Type{M}) where {M<:OperatorIndex} -> OperatorSum
zero(::Type{M}) where {M<:OperatorPack} -> OperatorSum
zero(::Type{M}) where {M<:OperatorSum} -> OperatorSum

Get the zero sum.

dot(m₁::QuantumOperator, m₂::QuantumOperator)
dot(m::QuantumOperator, c::Number)
dot(c::Number, m::QuantumOperator)

Dot product between two QuantumOperators or between a QuantumOperator and a number.

ishermitian(id::ZeroAtLeast{OperatorIndex}) -> Bool

Judge whether an id is Hermitian.

ishermitian(opts::Operators) -> Bool

Judge whether a set of operators as a whole is Hermitian.

ishermitian(m::Operator) -> Bool

Judge whether an operator is Hermitian.

mul!(ms::OperatorSum, factor::Number) -> OperatorSum

Get the in-place multiplication of an OperatorSum with a number.

rank(id::ZeroAtLeast{OperatorIndex}) -> Int
rank(::Type{<:ZeroAtLeast{OperatorIndex, N}}) where N -> Int

Get the rank of an id.

rank(m::OperatorProd) -> Int
rank(::Type{M}) where {M<:OperatorProd} -> Int

Get the rank of an OperatorProd.

⊗(id::OperatorIndex...)
⊗(u::OperatorIndex, id::ZeroAtLeast{OperatorIndex})
⊗(id::ZeroAtLeast{OperatorIndex}, u::OperatorIndex)
⊗(id₁::ZeroAtLeast{OperatorIndex}, id₂::ZeroAtLeast{OperatorIndex})

Get the id from operator units/ids.

idtype(m::OperatorPack)
idtype(::Type{T}) where {T<:OperatorPack}

Get the type of the id of an OperatorPack.

isequivalenttoscalar(m::QuantumOperator) -> Bool
isequivalenttoscalar(::Type{M}) where {M<:QuantumOperator} -> Bool

Judge whether a QuantumOperator is equivalent to a scalar.

isequivalenttoscalar(::Type{<:OperatorPack}) -> Bool
isequivalenttoscalar(::Type{<:OperatorPack{V, Tuple{}} where V}) -> Bool

Judge whether an OperatorPack is equivalent to a scalar.

latexformat(T::Type{<:OperatorIndex}) -> LaTeX
latexformat(T::Type{<:OperatorIndex}, l::LaTeX) -> LaTeX

Get/Set the LaTeX format for a subtype of OperatorIndex.

latexname(T::Type{<:OperatorIndex}) -> Symbol

Get the name of a type of OperatorIndex in the latex format lookups.

matrix

Generic matrix representation.

operatortype(m::QuantumOperator)

Get the operator type of a QuantumOperator, which is defined to be the type it corresponds to so that addition between two such objects can be performed directly. Usually, it is a subtype of OperatorPack.

operatortype(::Type{M}) where {M<:OperatorIndex}
operatortype(::Type{M}) where {M<:OperatorPack}
operatortype(::Type{M}) where {M<:OperatorSet}

Get the corresponding OperatorPack type of a quantum operator.

scalartype(t)
scalartype(::Type{T}) where {T<:Number}
scalartype(::Type{<:AbstractArray{T}}) where T
scalartype(::Type{<:ZeroAtLeast{T}}) where T

Get the scalar type of an object.

scalartype(::Type{M}) where {M<:QuantumOperator}

Get the scalar type of a QuantumOperator.

scalartype(::Type{T}) where {T<:OperatorPack}

Scalar type of the coefficient of an OperatorPack.

script(u::OperatorIndex, l::LaTeX, ::Val{:BD}) -> Any
script(u::OperatorIndex, l::LaTeX, ::Val{:SP}) -> Tuple
script(u::OperatorIndex, l::LaTeX, ::Val{:SB}) -> Tuple

Get the body/superscript/subscript of the LaTeX string representation of an operator index.

script(u::OperatorIndex, ::Val{}; kwargs...) -> String

Default script for an operator index, which always return an empty string.

sequence(m::OperatorProd, table) -> NTuple{rank(m), Int}

Get the sequence of the id of a quantum operator according to a table.

add!(destination, transformation::LinearTransformation, op::OperatorPack; kwargs...) -> typeof(destination)
add!(destination, transformation::LinearTransformation, op::OperatorSet; kwargs...) -> typeof(destination)

Add the result of the linear transformation on a quantum operator to the destination.

add!(ms::OperatorSum) -> typeof(ms)
add!(ms::OperatorSum, m::Union{Number, OperatorIndex, OperatorPack}) -> typeof(ms)
add!(ms::OperatorSum, mms::OperatorSum) -> typeof(ms)

Get the in-place addition of quantum operators.

div!(ms::OperatorSum, factor::Number) -> OperatorSum

Get the in-place division of an OperatorSum with a number.

expand(m::QuantumOperator) -> typeof(m)

Expand a QuantumOperator, which is defined to be itself.

id(m::OperatorPack) -> idtype(m)

Get the id of an OperatorPack.

sub!(ms::OperatorSum) -> typeof(ms)
sub!(ms::OperatorSum, m::Union{Number, OperatorIndex, OperatorPack}) -> typeof(ms)
sub!(ms::OperatorSum, mms::OperatorSum) -> typeof(ms)

Get the in-place subtraction of quantum operators.

update!(m::QuantumOperator; parameters...) -> typeof(m)

Update the parameters of a QuantumOperator in place and return the updated one.

By default, the parameter update of a QuantumOperator does nothing.

value(m::OperatorPack) -> valtype(m)

Get the value of an OperatorPack.