SecondOrderPerturbationTheory

Metric(::EDKind{:FED}, hilbert::Hilbert{<:Fock}) -> OperatorUnitToTuple
Metric(::EDKind{:SED}, hilbert::Hilbert{<:Spin}) -> OperatorUnitToTuple

Get the index-to-tuple metric for a free fermionic/bosonic system or a free phononic system.

BinaryBases{B<:BinaryBasis, T<:AbstractVector{B}} <: Sector

A set of binary bases.

BinaryBases(nstate::Integer, nparticle::Integer)
BinaryBases(states, nparticle::Integer)

Construct a set of binary bases that preserves the particle number conservation.

BinaryBases(nstate::Integer)
BinaryBases(states)

Construct a set of binary bases that does not preserve the particle number conservation.

BinaryBasis{I<:Unsigned}

Binary basis represented by an unsigned integer.

BinaryBasis(states; filter=index->true)
BinaryBasis{I}(states; filter=index->true) where {I<:Unsigned}

Construct a binary basis with the given occupied orbitals.

BinaryBasisRange{I<:Unsigned} <: VectorSpace{BinaryBasis{I}}

A continuous range of binary basis.

ED{K<:EDKind, L<:AbstractLattice, G<:OperatorGenerator, M<:Image} <: Frontend

Exact diagonalization method of a quantum lattice system.

ED(lattice::AbstractLattice, hilbert::Hilbert, terms::Tuple{Vararg{Term}}, targetspace::TargetSpace; neighbors::Union{Nothing, Int, Neighbors}=nothing, boundary::Boundary=plain)

Construct the exact diagonalization method for a quantum lattice system.

EDKind{K}

The kind of the exact diagonalization method applied to a quantum lattice system.

EDMatrix{S<:Sector, M<:SparseMatrixCSC} <: OperatorPack{M, Tuple{S, S}}

Matrix representation of quantum operators between a ket and a bra Hilbert space.

EDMatrix(sector::Sector, m::SparseMatrixCSC)

Construct a matrix representation when the ket and bra spaces share the same bases.

EDMatrixRepresentation{S<:Sector, T} <: MatrixRepresentation

Exact matrix representation of a quantum lattice system on a target Hilbert space.

EDMatrixRepresentation(target::TargetSpace, table)

Construct a exact matrix representation.

abstract type Sector <: OperatorUnit

A sector of the Hilbert space which form the bases of an irreducible representation of the Hamiltonian of a quantum lattice system.

SectorFilter{S} <: LinearTransformation

Filter the target bra and ket Hilbert spaces.

TargetSpace{S<:Sector} <: VectorSpace{S}

The target Hilbert space in which the exact diagonalization method is performed, which could be the direct sum of several sectors.

TargetSpace(sector::Sector, sectors::Sector...)

Construct a target space from sectors.

count(basis::BinaryBasis) -> Int
count(basis::BinaryBasis, start::Integer, stop::Integer) -> Int

Count the number of occupied single-particle states.

isone(basis::BinaryBasis, state::Integer) -> Bool

Judge whether the specified single-particle state is occupied for a basis.

iszero(basis::BinaryBasis, state::Integer) -> Bool

Judge whether the specified single-particle state is unoccupied for a basis.

iterate(basis::BinaryBasis, state=nothing)

Iterate over the numbers of the occupied single-particle orbitals.

one(basis::BinaryBasis, state::Integer) -> BinaryBasis

Get a new basis with the specified single-particle state occupied.

zero(basis::BinaryBasis, state::Integer) -> BinaryBasis

Get a new basis with the specified single-particle state unoccupied.

eigen(m::EDMatrix; nev=6, which=:SR, tol=0.0, maxiter=300, sigma=nothing, v₀=dtype(m)[]) -> Eigen

Solve the eigen problem by the restarted Lanczos method provided by the Arpack package.

⊕(sector::Sector, sectors::Union{Sector, TargetSpace}...) -> TargetSpace
⊕(target::TargetSpace, sectors::Union{Sector, TargetSpace}...) -> TargetSpace

Get the direct sum of sectors and target spaces.

⊗(bs₁::BinaryBases, bs₂::BinaryBases) -> BinaryBases

Get the direct product of two sets of binary bases.

⊗(basis₁::BinaryBasis, basis₂::BinaryBasis) -> BinaryBasis

Get the direct product of two binary bases.

matrix(ed::ED, sector::Sector; kwargs...) -> EDMatrix
matrix(ed::ED, sector=first(ed.Hₘ.transformation.brakets); kwargs...) -> EDMatrix

Get the sparse matrix representation of a quantum lattice system in a sector of the target space.

matrix(op::Operator, braket::NTuple{2, BinaryBases}, table; dtype=valtype(op)) -> SparseMatrixCSC{dtype, Int}
matrix(ops::Operators, braket::NTuple{2, BinaryBases}, table; dtype=valtype(eltype(ops))) -> SparseMatrixCSC{dtype, Int}

Get the CSC-formed sparse matrix representation of an operator.

Here, table specifies the order of the operator ids.

productable(bs₁::BinaryBases, bs₂::BinaryBases) -> Bool

Judge whether two sets of binary bases could be direct producted.

sumable(bs₁::BinaryBases, bs₂::BinaryBases) -> Bool

Judge whether two sets of binary bases could be direct summed.

Strictly speaking, two sets of binary bases could be direct summed if and only if they have no intersection. The time complexity to check the intersection is O(n log n), which costs a lot when the dimension of the binary bases is huge. It is also possible to judge whether they could be direct summed by close investigations on their ids, i.e. the single-particle states and occupation number. It turns out that this is a multi-variable pure integer linear programming problem. In the future, this function would be implemented based on this observation. At present, the direct summability should be handled by the users in priori.

BinaryConfigure{I<:TargetSpace, P<:Int} <: CompositeDict{P, I}
BinaryConfigure(ps::Pair...)
BinaryConfigure(kv)

Construct BinaryConfigure at a lattice. The local binary configure is given by BinaryConfigure.

Coefficience{P<:Int, I<:AbstractVector{<:Matrix{<:Number}}} <: Action

Decompose the projected-hamiltionian matrix with respect to input physical observables.

Coefficience(bonds::AbstractVector{<:Bond}, observables::Dict{Int, I}; options...) where {I<:Union{AbstractVector{<:AbstractMatrix}, Tuple{Vararg{Term}}}}
Coefficience(bonds::AbstractVector{<:Bond}, observables::Dict{Int, I}; options...) where {I<:Union{AbstractVector{<:AbstractMatrix}, Tuple{Vararg{Term}}}}
Coefficience(bonds::AbstractVector{<:Bond}, npoints::Int, ob::I=Tuple{}(); options...) where {I<:Union{AbstractVector{<:AbstractMatrix}, Tuple{Vararg{Term}}}}

η attribute in options is truncation of completeness of physical quantities. order attribute (order=-1,0,2) choose the order of matrix of effective hamiltonian to obtain the exchange coefficiences. npoints = length(lattice).

PickState{I<:Vector{Vector{Int}}, P<:Int} <: CompositeDict{P, I}
PickState(ps::Pair...)
PickState(kv)

Construct PickState. Pick low-energy states at a lattice.

ProjectState{V<:Real, C<:Number, P<:TargetSpace}

Projected states contain eigenvalues, eigenvectors, and basis of H₀.

ProjectState(ops::Operators, braket::BinaryBases, table; pick::Union{UnitRange{Int}, Vector{Int}, Colon}=:)
ProjectState(ops::Operators, ts::TargetSpace, table, pick::Vector{Vector{Int}})

Construct ProjectState. The pick::Union{UnitRange{Int}, Vector{Int}, Colon} argument picks the low-energy states. The i-th element of arguement pick vector is the loaction of low-energy states in the i-th Sector of TargetSpace.

ProjectStateBond

A type. Projected states on a bond. Construct ProjectStateBond by the ProjectStates defined on points. When bond.kind==2, the left (right) corresponds to the first (second) point in bond::Bond.

ProjectStateBond(left::ProjectState, right::ProjectState, nleft::Int, nright::Int)

The nleft and nright are the number of bits of left bit shift operator for left and right ProjectState, respectively.

SOPT{L<:AbstractLattice, G₁<:OperatorGenerator, G₀<:OperatorGenerator, PT<:SecondOrderPerturbation} <: Frontend

Second order perturbation theory method of a electronic quantum lattice system.

SOPT(lattice::AbstractLattice, hilbert::Hilbert, terms₁::Tuple{Vararg{Term}}, terms₀::Tuple{Vararg{Term}}, binaryconfigure::BinaryConfigure, lowstate::PickState; neighbors::Union{Nothing, Int, Neighbors}=nothing, boundary::Boundary=plain)

Construct the second order perturbation method for a quantum lattice system.

SOPTMatrix(bond::Bond, P₀::ProjectStateBond, m₀::Matrix, m₂::Matrix)

Matrix representation of the low-energy hamiltionian. The proper order for representing basis vectors is to start with the left space (bond[1]) and then proceed to the right space (bond[2]), i.e. kron(right, left).

Arguments

-bond: bond of lattice -P₀: projected state -m₀: matrix representation of the zeroth order (<H₀>) of the low-energy hamiltionian -m₀₁: matrix representation of the zeroth order (<H₁>) of the low-energy hamiltionian -m₂: matrix representation of second order of the low-energy hamiltionian

SecondOrderPerturationMetric <: Metric

Define the table metric, (:spin, :orbital) for a point, (:rcoordinate,:site, :spin, :orbital) for a bond.

SecondOrderPerturbation{B<:BinaryConfigure, L<:PickState} <: Transformation
(::SecondOrderPerturbation)(H₁::OperatorGenerator, p₀::Dict{T,<:ProjectState}, qₚ::Dict{T,<:ProjectState}, qₘ::Dict{T,<:ProjectState}, bond::Bond) where T<:Int  -> SOPTMatrix
(::SecondOrderPerturbation)(H₀::OperatorGenerator, H₁::OperatorGenerator, bond::Bond) -> SOPTMatrix

A type.

Base.:(<<)(bs::BinaryBases, n::Int) -> BinaryBases

Base.:(<<)(ps::ProjectState, n::Int) -> ProjectState

Left bit shift opeartor. The BinaryBasis is left shifted by n bits.

⊕(ps₁::ProjectState, ps₂::ProjectState) -> ProjectState

Get the direct sum of two projected states.

⊗(ps₁::ProjectState, ps₂::ProjectState) -> ProjectState

Get the direct product of two sets of projected states.

matrix(ops::Operators, ts₁::TargetSpace, ts₂::TargetSpace, table) -> Matrix
matrix(ops::Operators, ts::TargetSpace, table) -> Matrix

Get the matrix of direct sum of submatrices.

matrix(sopt::SOPT, bond::Bond) -> SOPTMatrix

Return matrix of the projected hamiltionian onto a bond of which the length is greater than 1.

dimension(ps::ProjectState) -> Int

The dimension of local low-energy hilbert space.

dimension(ps::ProjectState,::Type{T}) where T<:TargetSpace -> Int

The dimension of target space basis.

expand(gen::OperatorGenerator, bond::Bond) -> Operators

⊠(bs₁::BinaryBases, bs₂::BinaryBases) -> Tuple{BinaryBases, Vector{Int}}

Get the direct product of two sets of binary bases, and the permutation vector. oxtimes=⊠

SpinOperatorGenerator(st::SOPT, coef::Coefficience; η::Float64=1e-14) -> OperatorGenerator

Only support the pseudospin-1/2 case. The zeeman term (Onsite term) is ommited when the ground states are not Krameter states.

coefficience_project(m₂::Matrix{<:Number}, bond::Bond, ob::Dict{Int, <:AbstractVector{<:Matrix{<:Number}}}, η::Float64=1e-14) -> Matrix

Get the coefficience of exchange interaction. The row index corresponds to bond[1], column index corresponds to bond[2].

coefficience_project(matbd::SOPTMatrix, coef::Coefficience, hilbert::Hilbert) -> Matrix

hamiltonianeff(psp::ProjectStateBond, psq::ProjectStateBond, h1::Operators, table::Table, bond::Union{Bond, Nothing}=nothing)   ->Tuple{Matrix, Matrix, Matrix}

Get the effective Hamiltonian, the first and second terms of the result correspond to the zero-th and 2nd perturbations respectively.

observables_project(terms::Tuple{Vararg{Term}}, point::Point, hilbert::Hilbert, psp::ProjectState) -> Vector{Matrix}

The order of Term in terms (Onsite) tuple determines the order of matrix in the result.

projectstate_points(bc::BinaryConfigure, ls::PickState, H₀::OperatorGenerator, points::AbstractVector{<:Point}) -> Tuple{Dict, Dict, Dict, Dict}

Construct the ProjectState` type of low-energy states with N-particle space, high-energy states with (N+1)-particle space, high-energy states with (N-1)-particle space, and high-energy states with N-particle space.

projectstate_points(sopt::SOPT) -> Tuple{Dict{Int, ProjectState}, Dict{Int, ProjectState}, Dict{Int, ProjectState}, Dict{Int, ProjectState}}

Construct ProjectState on all points. Construct the ProjectState` type of low-energy states with N-particle space, high-energy states with (N+1)-particle space, high-energy states with (N-1)-particle space, and high-energy states with N-particle space.