Documentation for ITensorsOpenSystems.Superfermions

anticommutatorapply(o) -> Sum

Compute the anticommutator action of operator o in the superfermion representation.

Arguments

• o: The operator for which the anticommutator action is to be computed.

Returns

A Sum object representing the anticommutator operator.

See Also

• leftapply
• rightapply
• commutatorapply

clear_cached_vacuums()

Deletes all memorized left vacuum states created by leftvacuum.

see also leftvacuum, delete_cached_vacuuum

commutatorapply(o) -> Sum

Compute the commutator action of operator o in the superfermion representation.

Arguments

• o: operator

Returns

A Sum object representing the commutator operator.

See Also

• leftapply
• rightapply
• anticommutatorapply

delete_cached_vacuuum(indices::Vector{<:Index})::MPS

Deletes the left vacuum state memorized by leftvacuum for the given set of indices. The deleted state is returned.

see also leftvacuum, clear_cached_vacuums

 leftapply(o::T) where {T<:Any}

Creates an autoMPO representation of the superfermion operator equivelant to left multiplying the density operator by o. o must be given as an autoMPO object.

Examples

# Build the operator standard Hilbert space operaotr C†_1 C_2 + N_1
o = OpSum()
o += "Cdag", 1 "C" 2
o += "N", 1

# Build the superfermion operator ρ →(C†_1 C_2 + N_1)ρ as an autoMPO object
l = leftapply(o)

# Build an MPO representation of l
indices = superfermioninds(4)
l_mpo = MPO(l,s)

see also rightapply, leftrightapply, commutatorapply, anticommutatorapply

leftrightapply(ol,or)
leftrightapply(ol::Op, or::Op)::Scaled{_FieldType,Prod{Op}}
leftrightapply(ol::Prod{T}, or::Prod{T})::Scaled{_FieldType,Prod{T}} where {T<:Op}
leftrightapply(
ol::Scaled{<:Number,Prod{T}},
or::Scaled{<:Number,Prod{T}},

)::Scaled{<:Number,Prod{T}} where {T<:Op}

Creates an autoMPO representation of the superfermion operator equivelant to simultaniously left multiplying the density operator by ol and right multiplying by or. ol and or must be given as autoMPO objects.

Examples

# Build the standard Hilbert space operator 2.0 C_1 C†_2
s_left = OpSum()
s_left += 2.0 "C", 1, "Cdag" 2

# Build the standard Hilbert space operator N_1 + 2.0 N_2
s_right = OpSum()
s_right += "N", 1
s_right += 2.0, "N", 2

# Build the superfermion operator ρ → (2.0 C_1 C†_2) ρ (N_1 + 2.0 N_2)
superfemion_op = leftrightapply(s_left,s_right)

# Construct superfermion MPO
indices = superfermioninds(2)
O = MPO(superfemion_op,indices)

see also leftapply, rightapply, commutatorapply, anticommutatorapply

leftvacuum([NoCache,] indices::Vector{<:Index})::MPS

Returns the left vacuum state for a set of superfermion indices. Memorization is used to avoid repeatedly recomputing the state for a given set of indices. If the NoCache option is given, the state will always be directly computed, without querrying or overwriting the cached state.

Examples

superfermion_indices = superfermioninds(5) # Create a set of indices describing a system 
leftvac1 = leftvacuum(superfermion_indices) # Create the left vacuum statte for the system, memorizing the result
leftvac2 = leftvacuum(superfermion_indices) # Uses the cached result. No additional calculation is carried out
leftvac3 = leftvacuum(NoCache, superfermion_indices) # Ignores the cahce and recomputes the left vacuum state 

See also clear_cached_vacuums, delete_cached_vacuuum`

lindbladdissipator(jump_op::AbstractString,i::Integer)::Sum

Creates an autoMPO superfermion representation of a Lindblad dissipator with a jump operator jump_op on (physical) site i.

Examples

dis = OpSum()

# Add dissipator, removing fermions from the system, on site 1
# 0.1 * (C ρ C† - 1/2 { C†C,ρ } )
extraction_rate = 0.1
dis += extraction_rate * lindbladdissipator("C",1)

# Add dissipator, injecting fermions into the system, on site 5
# 0.3 * ( C† ρ C - 1/2 { CC†,ρ })
injection_rate = 0.3
dis += injection_rate * lindbladdissipator("Cdag",5)

# Build operator as MPO
indices = superfermioninds(5)
dissipation_MPO = MPO(dis,indices)

see also leftrightapply, commutatorapply, anticommutatorapply, leftapply, rightapply

 rightapply(o::T) where {T<:Any}

Creates an autoMPO representation of the superfermion operator equivelant to right multiplying the density operator by o. o must be given as an autoMPO object.

Examples

# Build the operator standard Hilbert space operaotr C†_1 C_2 + N_1
o = OpSum()
o += "Cdag", 1 "C" 2
o += "N", 1

# Build the superfermion operator ρ →ρ(C†_1 C_2 + N_1) as an autoMPO object
r = leftapply(o)

# Build an MPO representation of r
indices = superfermioninds(4)
r_mpo = MPO(r,s)

see also leftapply, leftrightapply, commutatorapply, anticommutatorapply

superfermioncorrelation(state::MPS,op1::Union{String,Matrix},op2::Union{String,Matrix}; normalize=true)::Matrix{ITensors.promote_itensor_eltype(state)}

Calculates the correlation matrix for a pair of operators op1 and op2 for a given state, that is calculates the expectation of the operator op1i * op2j for i and j iterating through each physical site of the system.

Example

indices = superfermioninds(5)
rho = leftvacuum(indices)
g = superfermioncorrelation(rho,"Cdag","C")

see also superfermionexpect

superfermionexpect(state::MPS,oper::AbstractString;[sites,] normalize::Bool=true)::Vector{ITensors.promote_itensor_eltype(rho)}

Calculates the expectation value of the operator oper on each physical site of the superfermion state state. If the sites keyword is given, the expectation is only evaluated for those physical sites in the given range. If normalize is true the result will be normalized by the trace of the input state.

Example

indices = superfermioninds(5)
ρ = leftvacuum(indices)

# Compute the occupation of all sites
occupations = superfermionexpect(ρ,"N")

# Compute the occupation of only sites 1 and 3
occupations_1_and_3 = superfermionexpect(ρ,"N";sites=[1,3]) 

see also superfermioncorrelation

superfermioninds(n::Integer;conserve_qns=false)::Vector{<:Index}

Constructs a set of superfermion indices for n physical sites. That is the result will contain 2n indices, with n system indices and n ancilla indices. If conserve_qns=true then the indices will keep track of particle number flux.

superfermiontrace(rho::MPS)::ITensors.promote_itensor_eltype(rho)

Calculates the trace of the density matrix given as a superfermion state rho