Internals

Boson Operators

The basic boson type operator.

Constraints = SortedDict{Int,Type}

Type alias for container of MO-Index constraints

KroneckerDelta

Type representing a Kronecker delta of two or more MO-indices.

Operator

Abstact operator type which all concrete operator types (i.e. Epq, a†p) must extend.

SingletExcitationOperator

The basic E_pq type operator.

Spin

Enum type to represent spin up (α) and down (β)

SingletExcitationOperator

The T_pq type operator.

Base.:==(::Operator, ::Operator)

This has to be explicitly implemented for each operator type.

Base.isless(::Operator, ::Operator)

All operator types must implement how they should be sorted among themselves (isless(::O, ::O)) and with respect to all other operator types that it is expected to be used together with (isless(::A, ::B)).

The implementation for how it sorts among the same operator type should be implemented in the definition file for that operator type.

The implementation for how the type sorts compared to other operator types should be added to the src/operators/sorting.jl file. These should be dummy routines that simply return true or false, and do not depend on the contents of the operators.

Base.show(::IO, ::Tuple{Operator,Constraints,IndexTranslation})

All typed extending Operator must overload this function.

compact_deltas(deltas::Vector{KroneckerDelta})

Returns a new reduced Vector{KroneckerDelta} where there exists only one delta per group of equal indices.

Example:

δ_pq δ_qr δ_st -> δ_pqr δst

exchange_indices(d::KroneckerDelta, mapping)

Returns a new KroneckerDelta with indices exchanged according to the mapping

exchange_indices(::Operator, mapping)

All typed extending Operator must overload this function. It should return a new operator where all indices have been exchanged according to the mapping.

get_all_indices(::Operator)

All typed extending Operator must overload this function. It should return an iteratable over all the MO-indices contained in the operator in order.

reductive_commutator(::Operator, ::Operator)

Defines how operators commute. This will act as either a commutator or anticommutator depending on which reduces the rank of the resulting operators.

Returns a Tuple{Int,Expression} which gives the type of commutator used and the resulting expression. The type is signaled by returning 1 or -1 as the first element of the tuple. This represents the sign change by commutation which is 1 for a normal commutator $([A, B] = 0 ⇒ AB == BA)$ and -1 for an anticommutator $([A, B]_+ = 0 ⇒ AB = -BA)$

This should be implemented for all pairs of operators types that are expected to show up in the same expression. The implementations should be put in the src/operators/commutation_relations.jl file.