const basicoptions = Dict(
    :gauge => "gauge used to perform the Fourier transformation",
    :infinitesimal => "infinitesimal added to the diagonal of the matrix representation of the tight-binding Hamiltonian"
)

Basic options of tight-binding actions.

Metric(::Fermionic, hilbert::Hilbert{<:Fock{:f}}) -> OperatorIndexToTuple
Metric(::Bosonic, hilbert::Hilbert{<:Fock{:b}}) -> OperatorIndexToTuple
Metric(::Phononic, hilbert::Hilbert{<:Phonon}) -> OperatorIndexToTuple

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

Table(hilbert::Hilbert{Phonon{:}}, by::OperatorIndexToTuple{(kind, :site, :direction)})

Construct a index-sequence table for a phononic system.

BerryCurvature{B<:ReciprocalSpace, M<:BerryCurvatureMethod, O} <: Action

Berry curvature of energy bands.

BerryCurvature(reciprocalspace::ReciprocalSpace, method::BerryCurvatureMethod; options...)
BerryCurvature(reciprocalspace::ReciprocalSpace, μ::Real, d::Real=0.1, kx::T=nothing, ky::T=nothing; gauge=:rcoordinate, options...) where {T<:Union{Nothing, Vector{Float64}}}
BerryCurvature(reciprocalspace::BrillouinZone, bands::AbstractVector{Int}, abelian::Bool=true; gauge=:icoordinate, options...)
BerryCurvature(reciprocalspace::ReciprocalZone, bands::AbstractVector{Int}, abelian::Bool=true; gauge=:rcoordinate, options...)

Construct a BerryCurvature.

BerryCurvatureData{R<:ReciprocalSpace, C<:Array{Float64}, N<:Union{Vector{Float64}, Float64, Nothing}} <: Data

Data of Berry curvature, including:

1. reciprocalspace::R: reciprocal space on which the Berry curvature is computed.
2. values::C: Berry curvature for a certain set of bands.
3. chernnumber::N: if not nothing, Chern number of each energy band when it is a vector or total Chern number of all bands when it is a number.

abstract type BerryCurvatureMethod end

Abstract type for calculation of Berry curvature.

Bosonic{K} <: TBAKind{K}

Bosonic quantum lattice system.

CompositeTBA{
    K<:TBAKind,
    L<:Union{AbstractLattice, Nothing},
    S<:Union{OperatorSet{<:Operator}, Generator{<:OperatorSet{<:Operator}}},
    Q<:Quadraticization,
    H<:Union{OperatorSet{<:Quadratic}, Generator{<:OperatorSet{<:Quadratic}}},
    C<:Union{AbstractMatrix, Nothing}
} <:TBA{K, H, C}

Composite tight-binding approximation for quantum lattice systems.

DensityOfStates(brillouinzone::BrillouinZone, bands::Union{Colon, AbstractVector{Int}}=:, orbitals::Union{Colon, AbstractVector{Int}}...=:; options...)

Construct a DensityOfStates.

DensityOfStates{B<:BrillouinZone, A<:Union{Colon, AbstractVector{Int}}, L<:Tuple{Vararg{Union{Colon, AbstractVector{Int}}}}, O} <: Action

Density of states of a tight-binding system.

DensityOfStatesData <: Data

Data of density of states, including:

1. energies::Vector{Float64}: energy sample points.
2. values::Matrix{Float64}: density of states projected onto several certain sets of orbitals.

EnergyBands(reciprocalspace::ReciprocalSpace, bands::Union{Colon, AbstractVector{Int}}=:, orbitals::AbstractVector{Int}...; options...)

Construct an EnergyBands.

EnergyBands{L<:Tuple{Vararg{AbstractVector{Int}}}, R<:ReciprocalSpace, A<:Union{Colon, AbstractVector{Int}}, O} <: Action

Energy bands by tight-binding-approximation for quantum lattice systems.

EnergyBandsData{R<:ReciprocalSpace, W<:Union{Vector{Matrix{Float64}}, Nothing}} <: Data

Data of energy bands, including:

1. reciprocalspace::R: reciprocal space on which the energy bands are computed.
2. values::Matrix{Float64}: eigen energies of bands with each column storing the values on the same reciprocal point.
3. weights::W: if not nothing, weights of several certain sets of orbitals projected onto the energy bands.

FermiSurface(reciprocalspace::Union{BrillouinZone, ReciprocalZone}, μ::Real=0.0, bands::Union{Colon, AbstractVector{Int}}=:, orbitals::AbstractVector{Int}...; options...)

Construct a FermiSurface.

FermiSurface{L<:Tuple{Vararg{AbstractVector{Int}}}, B<:Union{BrillouinZone, ReciprocalZone}, A<:Union{Colon, AbstractVector{Int}}, O} <: Action

Fermi surface of a free fermionic system.

FermiSurfaceData{S<:ReciprocalScatter} <: Data

Data of Fermi surface, including:

1. values::S: points of the Fermi surface.
2. weights::Vector{Vector{Float64}}: weights of several certain sets of orbitals projected onto the Fermi surface.

Fermionic{K} <: TBAKind{K}

Fermionic quantum lattice system.

Fukui <: BerryCurvatureMethod

Fukui method to calculate Berry curvature of energy bands. see Fukui et al, JPSJ 74, 1674 (2005). Hall conductivity (single band) is given by

\[\sigma_{xy} = -{e^2\over h}\sum_n c_n, \nonumber \\ c_n = {1\over 2\pi}\int_{BZ}{dk_x dk_y Ω_{xy}}, \Omega_{xy}=(\nabla\times {\bm A})_z, A_{x}=i\langle u_n|\partial_x|u_n\rangle.\]

InelasticNeutronScatteringSpectra{R<:ReciprocalSpace, O} <: Action

Inelastic neutron scattering spectra.

InelasticNeutronScatteringSpectra(reciprocalspace::ReciprocalSpace, energies::AbstractVector{<:Number}; options...)

Construct an InelasticNeutronScatteringSpectra.

InelasticNeutronScatteringSpectraData{R<:ReciprocalSpace} <: Data

Data of inelastic neutron scattering spectra, including:

1. reciprocalspace::R: reciprocal space on which the inelastic neutron scattering spectra are computed
2. energies::Vector{Float64}: energy sample points.
3. values::Matrix{Float64}: rescaled intensity of inelastic neutron scattering spectra.

Kubo{K<:Union{Nothing, Vector{Float64}}} <: BerryCurvatureMethod

Kubo method to calculate the total Berry curvature of occupied energy bands. The Kubo formula is given by

\[\Omega_{ij}(\bm k)=\epsilon_{ijl}\sum_{n}f(\epsilon_n(\bm k))b_n^l(\bm k)=-2{\rm Im}\sum_v\sum_c{V_{vc,i}(\bm k)V_{cv,j}(\bm k)\over [\omega_c(\bm k)-\omega_v(\bm k)]^2},\]

where

\[ V_{cv,j}={\langle u_{c\bm k}|{\partial H\over \partial {\bm k}_j}|u_{v\bm k}\rangle}\]

v and c subscripts denote valence (occupied) and conduction (unoccupied) bands, respectively. Hall conductivity in 2D space is given by

\[\sigma_{xy}=-{e^2\over h}\int_{BZ}{dk_x dk_y\over 2\pi}{\Omega_{xy}}\]

Phononic <: TBAKind{:BdG}

Phononic quantum lattice system.

Quadratic{V<:Number, C<:AbstractVector} <: OperatorPack{V, Tuple{Tuple{Int, Int}, C, C}}

The unified quadratic form in tight-binding approximation.

Quadraticization{K<:TBAKind, T<:Table} <: LinearTransformation

The linear transformation that converts a rank-2 operator to its unified quadratic form.

SimpleTBA{
    K<:TBAKind,
    L<:Union{AbstractLattice, Nothing},
    H<:Union{Formula, OperatorSet{<:Quadratic}, Generator{<:OperatorSet{<:Quadratic}}},
    C<:Union{AbstractMatrix, Nothing}
} <:TBA{K, H, C}

Simple tight-binding approximation for quantum lattice systems.

TBA{K<:TBAKind, H<:Union{Formula, OperatorSet, Generator, Frontend}, C<:Union{Nothing, AbstractMatrix}} <: Frontend

Abstract type for free quantum lattice systems using the tight-binding approximation.

TBA{K}(H::Union{Formula, OperatorSet{<:Quadratic}, Generator{<:OperatorSet{<:Quadratic}}}, commutator::Union{AbstractMatrix, Nothing}=nothing) where {K<:TBAKind}
TBA{K}(lattice::Union{AbstractLattice, Nothing}, H::Union{Formula, OperatorSet{<:Quadratic}, Generator{<:OperatorSet{<:Quadratic}}}, commutator::Union{AbstractMatrix, Nothing}=nothing) where {K<:TBAKind}

TBA{K}(H::Union{OperatorSet{<:Operator}, Generator{<:OperatorSet{<:Operator}}}, q::Quadraticization, commutator::Union{AbstractMatrix, Nothing}=nothing) where {K<:TBAKind}
TBA{K}(lattice::Union{AbstractLattice, Nothing}, H::Union{OperatorSet{<:Operator}, Generator{<:OperatorSet{<:Operator}}}, q::Quadraticization, commutator::Union{AbstractMatrix, Nothing}=nothing) where {K<:TBAKind}

TBA(lattice::AbstractLattice, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain; neighbors::Union{Int, Neighbors}=nneighbor(terms))
TBA{K}(lattice::AbstractLattice, hilbert::Hilbert, terms::OneOrMore{Term}, boundary::Boundary=plain; neighbors::Union{Int, Neighbors}=nneighbor(terms)) where {K<:TBAKind}

Construct a tight-binding quantum lattice system.

TBAKind{K}

The kind of a free quantum lattice system using the tight-binding approximation.

TBAKind(T::Type{<:Term}, I::Type{<:Internal})

Depending on the kind of a Term type and an Internal type, get the corresponding TBA kind.

TBAMatrix{C<:Union{AbstractMatrix, Nothing}, T, H<:Hermitian{T, <:AbstractMatrix{T}}} <: AbstractMatrix{T}

Matrix representation of a free quantum lattice system using the tight-binding approximation.

TBAMatrixization{D<:Number, V<:Union{AbstractVector{<:Number}, Nothing}} <: Matrixization

Matrixization of the Hamiltonian of a tight-binding system.

eigen(tba::Union{TBA, Algorithm{<:TBA}}, k::Union{AbstractVector{<:Number}, Nothing}=nothing; kwargs...) -> Eigen
eigen(tba::Union{TBA, Algorithm{<:TBA}}, reciprocalspace::ReciprocalSpace; kwargs...) -> Tuple{Vector{<:Vector{<:Number}}, Vector{<:Matrix{<:Number}}}

Get the eigen values and eigen vectors of a free quantum lattice system.

eigen(m::TBAMatrix) -> Eigen

Solve the eigen problem of a free quantum lattice system.

eigvals(tba::Union{TBA, Algorithm{<:TBA}}, k::Union{AbstractVector{<:Number}, Nothing}=nothing; kwargs...) -> Vector{<:Number}
eigvals(tba::Union{TBA, Algorithm{<:TBA}}, reciprocalspace::ReciprocalSpace; kwargs...) -> Vector{<:Vector{<:Number}}

Get the eigen values of a free quantum lattice system.

eigvals(m::TBAMatrix) -> Vector

Get the eigen values of a free quantum lattice system.

eigvecs(tba::Union{TBA, Algorithm{<:TBA}}, k::Union{AbstractVector{<:Number}, Nothing}=nothing; kwargs...) -> Matrix{<:Number}
eigvecs(tba::Union{TBA, Algorithm{<:TBA}}, reciprocalspace::ReciprocalSpace; kwargs...) -> Vector{<:Matrix{<:Number}}

Get the eigen vectors of a free quantum lattice system.

eigvecs(m::TBAMatrix) -> Matrix

Get the eigen vectors of a free quantum lattice system.

matrix(tba::Union{TBA, Algorithm{<:TBA}}, k::Union{AbstractVector{<:Number}, Nothing}=nothing; gauge=:icoordinate, infinitesimal=infinitesimal(kind(tba.frontend)), kwargs...) -> TBAMatrix

Get the matrix representation of a free quantum lattice system.

add!(dest::AbstractMatrix, mr::TBAMatrixization, m::Quadratic; infinitesimal=0, kwargs...) -> typeof(dest)

Matrixize a quadratic form and add it to dest.

add!(dest::OperatorSum, q::Quadraticization{<:TBAKind{:TBA}}, m::Operator{<:Number, <:ID{CoordinatedIndex{<:Index, 2}}; kwargs...) -> typeof(dest)
add!(dest::OperatorSum, q::Quadraticization{<:TBAKind{:BdG}}, m::Operator{<:Number, <:ID{CoordinatedIndex{<:Index{<:FockIndex}}, 2}}; kwargs...) -> typeof(dest)
add!(dest::OperatorSum, q::Quadraticization{<:TBAKind{:BdG}}, m::Operator{<:Number, <:ID{CoordinatedIndex{<:Index{<:PhononIndex}}, 2}}; kwargs...) -> typeof(dest)

Get the unified quadratic form of a rank-2 operator and add it to dest.

dimension(tba::Union{TBA, Algorithm{<:TBA}}) -> Int

Get the dimension of the matrix representation of a free quantum lattice system.

commutator(k::TBAKind, hilbert::Hilbert{<:Internal}) -> Union{AbstractMatrix, Nothing}

Get the commutation relation of the single-particle operators of a free quantum lattice system using the tight-binding approximation.

infinitesimal(::TBAKind{:TBA}) -> 0
infinitesimal(::TBAKind{:BdG}) -> atol/5
infinitesimal(::Fermionic{:BdG}) -> 0

Infinitesimal used in the matrixization of a tight-binding approximation to be able to capture the Goldstone mode.

SampleNode(reciprocals::AbstractVector{<:AbstractVector{<:Number}}, position::Vector{<:Number}, bands::AbstractVector{Int}, values::Vector{<:Number}, ratio::Number)
SampleNode(reciprocals::AbstractVector{<:AbstractVector{<:Number}}, position::Vector{<:Number}, bands::AbstractVector{Int}, values::Vector{<:Number}, ratios::Vector{<:Number}=ones(length(bands)))

A sample node of a momentum-eigenvalues pair.

deviation(tba::Union{TBA, Algorithm{<:TBA}}, samplenode::SampleNode) -> Float64
deviation(tba::Union{TBA, Algorithm{<:TBA}}, samplesets::Vector{SampleNode}) -> Float64

Get the deviation of the eigenvalues between the sample points and model points.

optimize!(
    tba::Union{TBA, Algorithm{<:TBA}}, samplesets::Vector{SampleNode}, variables=keys(Parameters(tba));
    verbose=false, method=LBFGS(), options=Options()
) -> Tuple{typeof(tba), Optim.MultivariateOptimizationResults}

Optimize the parameters of a tight binding system whose names are specified by variables so that the total deviations of the eigenvalues between the model points and sample points minimize.

W90(path::AbstractString, prefix::AbstractString="wannier90"; name::Symbol=Symbol(prefix), projection::Bool=true)

Construct a quantum lattice system based on the files obtained from Wannier90.

W90 <: TBA{Fermionic{:TBA}, OperatorSum{W90Hoppings, NTuple{3, Int}}, Nothing}

A quantum lattice system based on the information obtained from Wannier90.

W90(lattice::Lattice, centers::Matrix{<:Real}, H::OperatorSum{W90Hoppings})
W90(lattice::Lattice, hilbert::Hilbert, H::OperatorSum{W90Hoppings})

Construct a quantum lattice system based on the information obtained from Wannier90.

In general, the Wannier centers could deviate from their corresponding atom positions. When centers::Matrix{<:Real} is used, the the Wannier centers are assigned directly. When hilbert::Hilbert is used, the Wannier centers will be approximated by their corresponding atom positions.

W90Hoppings <: OperatorPack{Matrix{Float64}, NTuple{3, Int}}

Hopping amplitudes among the Wannier orbitals in two unitcells with a fixed relative displacement.

Here,

1. the :value attribute represents the hopping amplitude matrix of Wannier orbitals,
2. the :id attribute represents the relative displacement of the two unitcells in basis of the lattice translation vectors.

W90Matrixization{V<:AbstractVector{<:Real}} <: Matrixization

Matrixization of the Hamiltonian obtained from Wannier90.

matrix(wan::W90, k::AbstractVector{<:Number}=SVector(0, 0, 0); gauge=:icoordinate, kwargs...) -> TBAMatrix

Get the matrix representation of a quantum lattice system based on the information obtained from Wannier90.

add!(dest::AbstractMatrix, mr::W90Matrixization, m::W90Hoppings; kwargs...) -> typeof(dest)

Matrixize a group of Wannier hoppings and add it to dest.

findblock(name::String, content::String) -> Union{Nothing, Vector{SubString{String}}}

Find a named block in the content of Wannier90 configuration files.

readbands(path::AbstractString, prefix::AbstractString="wannier90") -> Tuple{Vector{Float64}, Matrix{Float64}}

Read the band structure from Wannier90 files by setting "bands_plot = .true.".

readcenters(path::AbstractString, prefix::AbstractString="wannier90") -> Matrix{Float64}

Read the centers of Wannier functions obtained by Wannier90.

readhamiltonian(path::AbstractString, prefix::AbstractString="wannier90") -> OperatorSum{W90Hoppings, NTuple{3, Int}}

Read the hamiltonian from the "_hr.dat" file generated by Wannier90.

readlattice(path::AbstractString, prefix::AbstractString="wannier90"; name::Symbol=Symbol(prefix), projection::Bool=true) -> Lattice{3, Float64, 3}

Read the lattice from the ".win" configuration file of Wannier90 with a given name.

Besides, projection specifies whether only the sites with initial projections in the ".win" file are included in the constructed lattice.