Input Functions

The high-level function mostly used is add_operator(…) that takes in an operator string and adds it to the Operator. While the function is capable of handling Hamiltonian terms and jump operators directly we have added the following wrapper to add a jump operator directly via add_jump_operator(…). New local operators can be added with define_operator(…). A diagonal shift is added with add_diagonal(…).

int32_t danceq::internal::Operator::add_operator(const ScalarType coef, const std::vector<uint64_t> sites_to_act, const std::vector<std::string> operator_string, const OperatorType OT_term = Hamiltonian, const bool print_warning = true)

Adds a new term to the operator.

coef is an overall coefficient, sites_to_act contains the sites on which the operator_string acts. OT_term is an OperatorType and can be either danceq::Hamiltonian or danceq::Lindbladian (to define a jump operator).

The operators listed in operator_string have to me included in available_operators.

Sites have to be within 0 and L-1.

sites_to_act and operator_string have to be of the same size.

If multiple operators act on the same site, the function internally defines their product and adds it to available_operators in the given order.

The following example adds a Hamiltonian term, see OperatorType, \(S^z_3S^z_4\) acting on sites 3 and 4:
H.add_operator(1., {3,4}, {"Sz","Sz"}, danceq::Hamiltonian);
Jump operators can be added with:
L.add_operator(1., {3}, {"Sz"}, danceq::Lindbladian);

All added operators are stored in operators_list. Internally, the function calls merge_terms(…) which sets up the sparse_matrices_for_computation to ensure a fast computation. Ntensor_max defines the maximal cluster size to generate a tensor matrix of size \(\textbf{Q}^{\textbf{Ntensor_max}}\). See here for more information.

Parameters:

coef – Overall coefficient
sites_to_act – Sites on which each operators act
operator_string – Operators that are applied to each site
OT_term – OperatorType (Hamiltonian/Lindbladian) (Default: Hamiltonian)
print_warning – Prints warning if true (Default: true)

Returns:

error_code

int32_t danceq::internal::Operator::add_jump_operator(const ScalarType coef, const std::vector<uint64_t> sites_to_act, const std::vector<std::string> operators_to_apply, const bool print_warning = true)

Adds a new jump operator.

This function is a simple wrapper of add_operator(…) that fixes OperatorType OT_term=Lindbladian.

Parameters:

coef – Overall coefficient
sites_to_act – Sites on which each operators act
operators_to_apply – Operators that are applied to each site
print_warning – Prints warning if true (Default: true)

Returns:

error_code

int32_t danceq::internal::Operator::define_operator(std::string name, std::array<std::array<ScalarType, state_class::template_struct::template_Q>, state_class::template_struct::template_Q> matrix)

Adds an operator to the available operators.

Adds an operator to available_operators. If the name already exists, it will be replaced.

\[\langle i \vert O \vert j \rangle = \delta_{i,j+1}\]

std::array< std::array<double, Q>, Q> matrix;
for(uint64_t i_for = 0UL; i_for < Q; i_for++){
    for(uint64_t j_for = 0UL; j_for < Q; j_for++){
        if(i_for != j_for + 1){
            matrix[i_for][j_for] = 0.; // two-dimensional array has to be set to zer
        } else {
            matrix[i_for][j_for] = 1.;
        }
    }
}
H.define_operator("O",matrix);

Parameters:

name – Name of the operator
matrix – Interaction matrix of size Q times Q in form of an two-dimensional array

Returns:

error_code

int32_t danceq::internal::Operator::add_diagonal(const ScalarType val)

Adds a diagonal shift.

Adds a constant to the diagonal of the operator:

\[O = O + \textbf{val} \cdot \mathbb{1}\otimes \dots \otimes \mathbb{1}\]

The diagonal is initially set to zero.

Parameters:: val – Adding val a diagonal contribution
Returns:: error_code

int32_t danceq::internal::Operator::set_Ntensor_max(const uint64_t Ntensor_max_input)

Sets Ntensor_max.

Parameters:: Ntensor_max_input – New value
Returns:: error_code

int32_t danceq::internal::Operator::merge_terms(const bool transpose = false)

Identifies non-local subclusters to merge all operator strings that are fully supported on such a clusters.

The function groups sites into clusters to improve the performance and creates the std::tuple in sparse_matrices_for_computation. Each term that is listed in operator_list will be assigned to a cluster in order to optimize the computation.

An example: In an one-dimensional spin chain with periodic boundary condition and nearest-neighbor terms of size \(L=30\) we can define three clusters containing sites \(C_0=\{0,\dots,10\}\), \(C_1=\{10,\dots,20\}\), and \(C_2=\{0,20,\dots,29\}\). Hence, we only define three sparse matrices of size \(2^{11}\). For example, the terms \(S^x_3S^x_4\) and \(S^y_7S^y_8\) are assigned to the first cluster \(C_0\), and \(S^x_{16}S^x_{17}\) is assigned to the second cluster \(C_1\).

The maximal cluster size can is given by Ntensor_max and cane be set by calling set_Ntensor_max(…). Its default value is chosen such that the tensor matrix does not exceeds the dimension of 2028. However, if terms acting on more than Ntensor_max sites (e.g., long loop updates), Ntensor_max is increased. This function is called by add_operator(…).

The transposed problem will be encoded by setting transpose to true.

Parameters:: transpose – Sets the transposed problem
Returns:: error_code

int32_t danceq::internal::Operator::add_default_operators(void)

Adds some local default operators.

The function adds the following local operator to available_operators: {"Sx","Sy","Sz","S+","S-","n","R","Rdag","P"+std::to_string(k)} for \(k=0,\dots,\textbf{Q}-1`\).

For spin operators, \(m,m^\prime =-S,-S+1,\dots,S\) with \(S = (\textbf{Q}-1)/2\):

\[\begin{split}\langle m^\prime \vert S^x \vert m \rangle &= \left( \delta_{m^\prime,m+1} + \delta_{m^\prime,m+1}\right)\frac{1}{2}\sqrt{S(S+1)-m^\prime m}\\ \langle m^\prime \vert S^y \vert m \rangle &= \left( \delta_{m^\prime,m+1} - \delta_{m^\prime,m+1}\right)\frac{1}{2i}\sqrt{S(S+1)-m^\prime m}\\ \langle m^\prime \vert S^z \vert m \rangle &= \delta_{m^\prime,m}m\\ \langle m^\prime \vert S^+ \vert m \rangle &= \delta_{m^\prime,m+1}\sqrt{S(S+1)-m^\prime m}\\ \langle m^\prime \vert S^- \vert m \rangle &= \delta_{m^\prime+1,m}\sqrt{S(S+1)-m^\prime m}\end{split}\]

\(\vert m\rangle\) refer to qudit states: \(\vert 0\rangle, \dots,\vert \textbf{Q}-1\rangle\).

We further define more general qudit operators:

\[\begin{split}\langle i \vert n \vert j \rangle &= \delta_{i,j} i\\ \langle i \vert R \vert j \rangle &= \delta_{i,j+1}\\ \langle i \vert R^\dagger \vert j \rangle &= \delta_{i+1,j}\\ \langle i \vert P_k \vert j \rangle &= \delta_{i,k}\delta_{k,j}\end{split}\]

Returns:: error_code

int32_t danceq::internal::Operator::merge_given_terms(std::vector<uint64_t> &cluster, std::vector<std::pair<uint64_t, danceq::internal::ResolvedAction>> &list_of_terms, const bool transpose)

Merges given terms that are all defined on the given cluster.

This function is only called internally by merge_terms(…). It merges the terms given in list_of_terms which refers to operator_list into a single entry in sparse_matrices_for_computation that is used in apply(…). All terms are fully supported on the given cluster. The second argument in list_of_terms refers to the precise action on the wavefunction or density matrix as specified in ResolvedAction.

The transposed problem will be encoded by setting transpose to true.

Parameters:

cluster – Sites on which the matrix is defined
list_of_terms – Terms that are included
transpose – Boolean to generate the transposed problem

Returns:

error_code

enum danceq::internal::ResolvedAction

Defines the precise action of a term to the wavefunction or density matrix.

This is primarily used for the Lindbladian OperatorType where each jump operator \(l\) acts three times on a density matrix:

\[\frac{\text{d}\rho}{\text{d}t} = \gamma l\rho l^\dagger - \gamma\frac{1}{2}l^\dagger l\rho - \gamma\frac{1}{2}\rho l^\dagger l\]

Each term in the Hamiltonian \(h\) acts two times on the density matrix \(\rho\) according von Neumann equation

\[\frac{\text{d}\rho}{\text{d}t} = -ih\rho +i\rho h\]

Values:

enumerator wavefunction: Action of a term in Hamiltonian to the wavefunction.

enumerator density_matrix_commutator_left: Action of a term in the Hamiltonian from the left of the density matrix coming from the commutator.

enumerator density_matrix_commutator_right: Action of a term in the Hamiltonian from the right of the density matrix coming from the commutator.

enumerator density_matrix_jump_operator_both_sites: Action of a jump operator from both sides of the density matrix.

enumerator density_matrix_jump_operator_anti_commutator_left: Action of a jump operator from the left of the density matrix coming from the anti commutator.

enumerator density_matrix_jump_operator_anti_commutator_right: Action of a jump operator from the right of the density matrix coming from the anti commutator.