Unitary Coupled Cluster Base

class slowquant.unitary_coupled_cluster.base.StateVector(inactive: list[ndarray], active: list[ndarray], virtual: list[ndarray])

State vector.

Initialize state vector.

Parameters:

inactive – Kronecker representation of inactive orbitals (reference).
active – Kronecker representation of active orbitals (reference).
virtual – Kronecker representation of virtual orbitals (reference).

property bra_active: ndarray: Get bra state-vector for active orbitals.

property bra_active_csr: csr_matrix: Get bra state-vector for inactive orbitals.

property bra_inactive: list[ndarray]: Get bra configuration for inactive orbitals.

property bra_virtual: list[ndarray]: Get bra configuration for virtual orbitals.

property ket_active: ndarray: Get ket state-vector for inactive orbitals.

property ket_active_csr: csr_matrix: Get ket state-vector for inactive orbitals.

property ket_inactive: list[ndarray]: Get ket configuration for inactive orbitals.

property ket_virtual: list[ndarray]: Get ket configuration for virtual orbitals.

new_u(U: ndarray, allowed_states: ndarray | None = None) → None

Create active state-vector by applying transformation matrix to reference.

Parameters:

U – Transformation matrix.
allowed_states – State to be transformed.

slowquant.unitary_coupled_cluster.base.kronecker_product(A: Sequence[ndarray]) → ndarray

Get Kronecker product of a list of matricies.

Does:

\[P x P x P ...\]

Parameters:: A – List of matrices.
Returns:: Kronecker product of matrices.

slowquant.unitary_coupled_cluster.base.kronecker_product_cached(num_prior: int, num_after: int, pauli_mat_symbol: str, is_csr: bool, is_z_prior: bool = False) → ndarray | csr_matrix

Get operator in matrix form.

The operator is returned in the form:

\[I x I x .. o .. x I x I\]

or

\[Z x Z x .. o .. x I x I\]

Parameters:

num_prior – Number of left-hand side identity matrices.
num_after – Number of right-hand side identity matrices.
is_csr – If the resulting matrix representation should be a sparse matrix.
is_z_prior – Use the Z operator instead of identiy operator as the prior matricies.

Returns:

Matrix representation of an operator.

slowquant.unitary_coupled_cluster.base.symbol_to_mat(symbol: str) → ndarray

Convert operator matrix symbol to matrix representation.

The symbol needs to be representable by a 2x2 matrix.

Parameters:: symbol – Symbol matrix symbol.
Returns:: Matrix representation of symbol.

slowquant.unitary_coupled_cluster.linalg_wrapper.expm(A: ndarray | csr_matrix | csc_matrix) → ndarray | csr_matrix | csc_matrix

Matrix exponential that is agnostic to dense (numpy) and sparse (scipy) matrices.

Parameters:: A – Matrix.
Returns:: Matrix exponential of A.

Matrix multiplication that is agnostic to dense (numpy) and sparse (scipy) matrices.

Parameters:

A – Matrix.
B – Matrix.

Returns:

Matrix product.

Outerp product between two vectors.

Parameters:

A – Vector.
B – Vector.

Returns:

Outer product matrix.

slowquant.unitary_coupled_cluster.linalg_wrapper.zeros_like(A: ndarray | csr_matrix | csc_matrix) → ndarray | csr_matrix | csc_matrix

Create zero array of same shape as input array.

Parameters:: A – Array to take shape from.
Returns:: Zero array.

class slowquant.unitary_coupled_cluster.density_matrix.ReducedDenstiyMatrix(num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int, rdm1: ndarray, rdm2: ndarray | None = None)

Reduced density matrix class.

Initialize reduced density matrix class.

Parameters:

num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.
rdm1 – One-electron reduced density matrix in the active space.
rdm2 – Two-electron reduced density matrix in the active space.

RDM1(p: int, q: int) → float

Get one-electron reduced density matrix element.

The only non-zero elements are:

\[\begin{split}\Gamma^{[1]}_{pq} = \left\{\begin{array}{ll} 2\delta_{ij} & pq = ij\\ \left<0\left|\hat{E}_{vw}\right|0\right> & pq = vw\\ 0 & \text{otherwise} \\ \end{array} \right.\end{split}\]

and the symmetry \(\Gamma^{[1]}_{pq}=\Gamma^{[1]}_{qp}\).

Parameters:

p – Spatial orbital index.
q – Spatial orbital index.

Returns:

One-electron reduved density matrix element.

RDM2(p: int, q: int, r: int, s: int) → float

Get two-electron reduced density matrix element.

\[\begin{split}\Gamma^{[2]}_{pqrs} = \left\{\begin{array}{ll} 4\delta_{ij}\delta_{kl} - 2\delta_{jk}\delta_{il} & pqrs = ijkl\\ 2\delta_{ij} \Gamma^{[1]}_{vw} & pqrs = vwij\\ - \delta_{ij}\Gamma^{[1]}_{vw} & pqrs = ivwj\\ \left<0\left|\hat{e}_{vwxy}\right|0\right> & pqrs = vwxy\\ 0 & \text{otherwise} \\ \end{array} \right.\end{split}\]

and the symmetry \(\Gamma^{[2]}_{pqrs}=\Gamma^{[2]}_{rspq}=\Gamma^{[2]}_{qpsr}=\Gamma^{[2]}_{srqp}\).

Parameters:

p – Spatial orbital index.
q – Spatial orbital index.
r – Spatial orbital index.
s – Spatial orbital index.

Returns:

Two-electron reduved density matrix element.

slowquant.unitary_coupled_cluster.density_matrix.get_electronic_energy(rdms: ReducedDenstiyMatrix, h_int: ndarray, g_int: ndarray, num_inactive_orbs: int, num_active_orbs: int) → float

Calculate electronic energy.

\[E = \sum_{pq}h_{pq}\Gamma^{[1]}_{pq} + \frac{1}{2}\sum_{pqrs}g_{pqrs}\Gamma^{[2]}_{pqrs}\]

Parameters:

h_int – One-electron integrals in MO.
g_int – Two-electron integrals in MO.
num_inactive_orbs – Number of inactive orbitals.
num_active_orbs – Number of active orbitals.

Returns:

Electronic energy.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_gradient(rdms: ReducedDenstiyMatrix, h_int: ndarray, g_int: ndarray, kappa_idx: list[list[int]], num_inactive_orbs: int, num_active_orbs: int) → ndarray

Calculate the orbital gradient.

\[g_{pq}^{\hat{\kappa}} = \left<0\left|\left[\hat{\kappa}_{pq},\hat{H}\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
h_int – One-electron integrals in MO in Hamiltonian.
g_int – Two-electron integrals in MO in Hamiltonian.
kappa_idx – Orbital parameter indicies in spatial basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.

Returns:

Orbital gradient.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_gradient_response(rdms: ReducedDenstiyMatrix, h_int: ndarray, g_int: ndarray, kappa_idx: list[list[int]], num_inactive_orbs: int, num_active_orbs: int) → ndarray

Calculate the response orbital parameter gradient.

\[g_{pq}^{\hat{q}} = \left<0\left|\left[\hat{q}_{pq},\hat{H}\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
h_int – One-electron integrals in MO in Hamiltonian.
g_int – Two-electron integrals in MO in Hamiltonian.
kappa_idx – Orbital parameter indicies in spatial basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.

Returns:

Orbital response parameter gradient.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_response_hessian_block(rdms: ReducedDenstiyMatrix, h: ndarray, g: ndarray, kappa_idx1: list[list[int]], kappa_idx2: list[list[int]], num_inactive_orbs: int, num_active_orbs: int) → ndarray

Calculate Hessian-like orbital-orbital block.

\[H^{\hat{q},\hat{q}}_{tu,mn} = \left<0\left|\left[\hat{q}_{tu},\left[\hat{H},\hat{q}_{mn}\right]\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
kappa_idx1 – Orbital parameter indicies in spatial basis.
kappa_idx1 – Orbital parameter indicies in spatial basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.

Returns:

Hessian-like orbital-orbital block.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_response_metric_sigma(rdms: ReducedDenstiyMatrix, kappa_idx: list[list[int]]) → ndarray

Calculate the Sigma matrix orbital-orbital block.

\[\Sigma_{pq,pq}^{\hat{q},\hat{q}} = \left<0\left|\left[\hat{q}_{pq}^\dagger,\hat{q}_{pq}\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
kappa_idx – Orbital parameter indicies in spatial basis.

Returns:

Sigma matrix orbital-orbital block.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_response_property_gradient(rdms: ReducedDenstiyMatrix, x_mo: ndarray, kappa_idx: list[list[int]], num_inactive_orbs: int, num_active_orbs: int, response_vectors: ndarray, state_number: int, number_excitations: int) → float

Calculate the orbital part of property gradient.

\[P^{\hat{q}} = \sum_k\left<0\left|\left[\hat{O}_{k},\hat{X}\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
x_mo – Property integral in MO basis.
kappa_idx – Orbital parameter indicies in spatial basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
response_vectors – Response vectors.
state_number – State number counting from zero.
number_excitations – Total number of excitations.

Returns:

Orbital part of property gradient.

slowquant.unitary_coupled_cluster.density_matrix.get_orbital_response_vector_norm(rdms: ReducedDenstiyMatrix, kappa_idx: list[list[int]], response_vectors: ndarray, state_number: int, number_excitations: int) → float

Calculate the orbital part of excited state norm.

\[N^{\hat{q}} = \sum_k\left<0\left|\left[\hat{O}_{k},\hat{O}_{k}^\dagger\right]\right|0\right>\]

Parameters:

rdms – Reduced density matrix class.
kappa_idx – Orbital parameter indicies in spatial basis.
response_vectors – Response vectors.
state_number – State number counting from zero.
number_excitations – Total number of excitations.

Returns:

Orbital part of excited state norm.

class slowquant.unitary_coupled_cluster.operator_hybrid.OperatorHybrid(operator: dict[str, OperatorHybridData])

Initialize hybrid operator.

The key is the Pauli-string of inactive + virtual, i.e. the active part does not contribute to the key.

Parameters:: operator – Dictonary form of hybrid operator.

property dagger: OperatorHybrid

Do complex conjugate of operator.

Returns:: New hybrid operator.

class slowquant.unitary_coupled_cluster.operator_hybrid.OperatorHybridData(inactive_pauli: str, active_matrix: ndarray | csr_matrix, virtual_pauli: str)

Initialize data structure of hybrid operators.

Parameters:

inactive_pauli – Pauli string of inactive orbitals.
active_matrix – Matrix operator of active orbitals.
virtual_pauli – Pauli string of virtual orbitals.

class slowquant.unitary_coupled_cluster.operator_hybrid.StateVectorOperator(state_vector: dict[str, StateVectorOperatorData])

Initialize ‘operator’ form of state vector.

Parameters:: state_vector – Data class representation of the state vector.

class slowquant.unitary_coupled_cluster.operator_hybrid.StateVectorOperatorData(inactive_orbs: str, active_space: ndarray | csr_matrix, virtual_orbs: str)

Initialize data class for state vector.

Parameters:

inactive_orbs – String representation of inactive orbitals occupation. o (one) meaning occupied and z (zero) meaning unoccupoed.
active_space – Active space part of state state vector.
virtual_orbs – String representation of virtual orbitals occupation. o (one) meaning occupied and z (zero) meaning unoccupoed.

slowquant.unitary_coupled_cluster.operator_hybrid.convert_pauli_to_hybrid_form(pauliop: OperatorPauli, num_inactive_orbs: int, num_active_orbs: int) → OperatorHybrid

Convert Pauli operator to hybrid operator.

Parameters:

pauliop – Pauli operator.
num_inactive_orbs – Number of inactive orbitals.
num_active_orbs – Number of active orbitals.

Returns:

Hybrid operator.

slowquant.unitary_coupled_cluster.operator_hybrid.epq_hybrid(p: int, q: int, num_inactive_spin_orbs: int, num_active_spin_orbs: int, num_virtual_spin_orbs: int) → OperatorHybrid

Get Epq operator.

Parameters:

p – Orbital index spatial basis.
q – Orbital index spatial basis.
num_inactive_spin_orbs – Number of inactive orbitals in spin basis.
num_active_spin_orbs – Number of active orbitals in spin basis.
num_virtual_spin_orbs – Number of virtual orbitals in spin basis.

Returns:

Epq hybrid operator.

slowquant.unitary_coupled_cluster.operator_hybrid.expectation_value_hybrid(bra: StateVector, hybridop: OperatorHybrid, ket: StateVector, use_csr: int = 10) → float

Calculate expectation value of hybrid operator.

Parameters:

bra – Bra state-vector.
hybridop – Hybrid operator.
ket – Ket state-vector.
use_csr – Size when to use sparse matrices.

Returns:

Expectation value of hybrid operator.

slowquant.unitary_coupled_cluster.operator_hybrid.expectation_value_hybrid_flow(state_vec: StateVector, operators: list[OperatorHybrid], ref_vec: StateVector) → float

Calculate expectation value of operator.

Parameters:

state_vec – Bra state vector.
operators – List of operators.
ref_vec – Ket state vector.

Returns:

Expectation value of operator.

slowquant.unitary_coupled_cluster.operator_hybrid.expectation_value_hybrid_flow_commutator(state_vec: StateVector, A: OperatorHybrid, B: OperatorHybrid, ref_vec: StateVector) → float

Calculate expectation value of commutator.

\[E = \left<n\left|\left[A,B\right]\right|m\right>\]

Parameters:

state_vec – Bra state vector.
A – First operator in commutator.
B – Second operator in commutator.
ref_vec – Ket state vector.

Returns:

Expectation value of commutator.

slowquant.unitary_coupled_cluster.operator_hybrid.expectation_value_hybrid_flow_double_commutator(state_vec: StateVector, A: OperatorHybrid, B: OperatorHybrid, C: OperatorHybrid, ref_vec: StateVector) → float

Calculate expectation value of double commutator.

\[E = \left<n\left|\left[A,\left[B,C\right]\right]\right|m\right>\]

Parameters:

state_vec – Bra state vector.
A – First operator in commutator.
B – Second operator in commutator.
C – Third operator in commutator.
ref_vec – Ket state vector.

Returns:

Expectation value of double commutator.

slowquant.unitary_coupled_cluster.operator_hybrid.hamiltonian_hybrid_0i_0a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorHybrid

Get energy Hamiltonian operator.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Energy Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_hybrid.hamiltonian_hybrid_1i_1a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorHybrid

Get Hamiltonian operator that works together with an extra inactive and an extra virtual index.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Modified Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_hybrid.hamiltonian_hybrid_2i_2a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorHybrid

Get Hamiltonian operator that works together with two extra inactive and two extra virtual index.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Modified Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_hybrid.make_projection_operator(state_vector: StateVector, use_csr: int = 10) → OperatorHybrid

Create a projection operator, \(|0><0|\), from a state vector.

Parameters:: state_vector – State vector class.
Returns:: Projection operator in hybrid form.

slowquant.unitary_coupled_cluster.operator_hybrid.one_elec_op_hybrid_0i_0a(ints_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorHybrid

Create one-electron operator that makes no changes in the inactive and virtual orbitals.

Parameters:

ints_mo – One-electron integrals for operator in MO basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

One-electron operator for active-space.

slowquant.unitary_coupled_cluster.operator_hybrid.one_elec_op_hybrid_1i_1a(ints_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorHybrid

Create one-electron operator that makes no changes in the inactive and virtual orbitals.

Parameters:

ints_mo – One-electron integrals for operator in MO basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

One-electron operator for active-space.

slowquant.unitary_coupled_cluster.operator_matrix.a_op_spin_matrix(idx: int, dagger: bool, number_spin_orbitals: int, use_csr: int = 10) → ndarray | csr_matrix

Get matrix representation of fermionic operator.

This is the matrix form that depends on number of electrons i.e.:

\[Z x Z x .. x a x .. I x I\]

Parameters:

idx – Spin orbital index.
dagger – Creation or annihilation operator.
number_spin_orbitals – Total number of spin orbitals.

Returns:

Matrix representation of ferminonic annihilation or creation operator.

slowquant.unitary_coupled_cluster.operator_matrix.epq_matrix(p: int, q: int, num_spin_orbs: int, use_csr: int = 10) → ndarray | csr_matrix

Contruct Epq operator.

Parameters:

p – Orbital index.
q – Orbital index.
num_spin_orbs – Number of spin orbitals.
use_csr – Size when to use sparse matrices.

Returns:

Epq operator in matrix form.

class slowquant.unitary_coupled_cluster.operator_pauli.OperatorPauli(operator: dict[str, complex])

Initialize Pauli operator.

Parameters:: operator – Pauli operator in dictionary form.

property dagger: OperatorPauli

Do complex conjugate of Pauli operator.

Returns:: New Pauli operator.

eval_operators(state_vector: StateVector) → dict[str, float]

Evalate operator per term.

Parameters:: state_vector – Bra and Ket state-vector.
Returns:: Expectation value of all terms in Pauli operator.

make_folded_operator(num_inactive_spin_orbs: int, num_virtual_spin_orbs: int) → OperatorPauli

Make a folded version of the operator.

A folded operator means that the inactive and virtual part is evaluted. This type of operator should not be used with operators that modify the inactive and virtual space.

Parameters:

num_inactive_spin_orbs – Number of inactive orbitals.
num_virtual_spin_orbs – Number of virtual orbitals.

Returns:

Folded operator.

matrix_form(use_csr: int = 10, is_real: bool = False) → ndarray | csr_matrix

Get matrix form of operator.

Parameters:

use_csr – Size for when to use sparse matrices.
is_real – Only return real part of matrix.

Returns:

Pauli operator in matrix form.

screen_terms(max_xy_inactive: int, max_xy_virtual: int, num_inactive_spin_orbs: int, num_virtual_spin_orbs) → OperatorPauli

Remove terms from the operator that has too many X or Y Pauli operators.

If it is known that a maximum number of Pauli operators can be changed before the expectation value of the operator is taken. Then terms with too many X and Y operators can be removed because they will always evaluate to zero.

Parameters:

max_xy_inactive – Maximum number of X and Y Pauli operators in the inactive orbitals.
max_xy_virtual – Maximum number of X and Y Pauli operators in the virtual orbitals.
num_inactive_spin_orbs – Number of inactive orbitals.
num_virtual_spin_orbs – Number of virtual orbitals.

Returns:

Screened Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.a_pauli(spinless_idx: int, spin: str, dagger: bool, num_spin_orbs: int) → OperatorPauli

Annihilation operator.

Parameters:

spinless_idx – Spatial orbital index.
spin – alpha or beta spin.
dagger – If complex conjugated.
num_spin_orbs – Number of spin orbitals.

Returns:

Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.a_spin_pauli(idx: int, dagger: bool, num_spin_orbs: int) → OperatorPauli

Annihilation operator with spin orbital index.

Parameters:

idx – Spin orbital index.
dagger – If complex conjugated.
num_spin_orbs – Number of spin orbitals.

Returns:

Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.commutator_pauli(A: OperatorPauli, B: OperatorPauli) → OperatorPauli

Calculate commutator of two Pauli operators.

Parameters:

A – Pauli operator.
B – Pauli operator.

Returns:

New Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.epq_pauli(p: int, q: int, num_spin_orbs: int) → OperatorPauli

Get Epq operator.

Parameters:

p – Orbital index.
q – Orbital index.
num_spin_orbs – Number of spin orbitals.

Returns:

Epq Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.epqrs_pauli(p: int, q: int, r: int, s: int, num_spin_orbs: int) → OperatorPauli

Get epqrs operator.

Parameters:

p – Orbital index.
q – Orbital index.
r – Orbital index.
s – Orbital index.
num_spin_orbs – Number of spin orbitals.

Returns:

epqrs Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.expectation_value_pauli(bra: StateVector, pauliop: OperatorPauli, ket: StateVector, use_csr: int = 10) → float

Calculate expectation value of Pauli operator.

Parameters:

bra – Bra state-vector.
pauliop – Pauli operator.
ket – Ket state-vector.
use_csr – Size for when to use sparse matrices.

Returns:

Expectation value of Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.hamiltonian_pauli(h_mo: ndarray, g_mo: ndarray, num_orbs: int) → OperatorPauli

Get full Hamiltonian operator.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_orbs – Number of spatial orbitals.

Returns:

Full Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.hamiltonian_pauli_0i_0a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorPauli

Get energy Hamiltonian operator.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Energy Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.hamiltonian_pauli_1i_1a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorPauli

Get Hamiltonian operator that works together with an extra inactive and an extra virtual index.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Modified Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.hamiltonian_pauli_2i_2a(h_mo: ndarray, g_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorPauli

Get Hamiltonian operator that works together with two extra inactive and two extra virtual index.

Parameters:

h_mo – One-electron Hamiltonian integrals in MO.
g_mo – Two-electron Hamiltonian integrals in MO.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Modified Hamilonian Pauli operator.

slowquant.unitary_coupled_cluster.operator_pauli.one_elec_op_pauli_0i_0a(ints_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorPauli

Create one-electron operator that makes no changes in the inactive and virtual orbitals.

Parameters:

ints_mo – One-electron integrals for operator in MO basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

One-electron operator for active-space.

slowquant.unitary_coupled_cluster.operator_pauli.one_elec_op_pauli_1i_1a(ints_mo: ndarray, num_inactive_orbs: int, num_active_orbs: int, num_virtual_orbs: int) → OperatorPauli

Create one-electron operator that makes up to one change in the inactive and virtual orbitals.

Parameters:

ints_mo – One-electron integrals for operator in MO basis.
num_inactive_orbs – Number of inactive orbitals in spatial basis.
num_active_orbs – Number of active orbitals in spatial basis.
num_virtual_orbs – Number of virtual orbitals in spatial basis.

Returns:

Modified one-electron operator.

class slowquant.unitary_coupled_cluster.util.ThetaPicker(active_occ_spin_idx: Sequence[int], active_unocc_spin_idx: Sequence[int], is_spin_conserving: bool = False)

Initialize helper class to iterate over active space parameters.

Parameters:

active_occ_spin_idx – Spin index of strongly occupied orbitals.
active_unocc_spin_idx – Spin index of weakly occupied orbitals.
is_spin_conserving – Generate spin conserving operators.

get_t1_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Get generate over T1 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T1 operator generator.

get_t1_generator_sa(num_spin_orbs: int) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Get generate over T1 spin-adapted operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T1 operator generator.

get_t1_generator_sa_matrix(num_spin_orbs: int, use_csr: int = 10) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Get generate over T1 spin-adapted operators in matrix form.

Parameters:

num_spin_orbs – Number of spin orbitals.
use_csr – Orbital limit for which sparse matrices will be used.

Returns:

T1 operator generator.

get_t2_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Get generate over T2 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T2 operator generator.

get_t2_generator_sa(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Get generate over T2 spin-adapted operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T2 operator generator.

get_t2_generator_sa_matrix(num_spin_orbs: int, use_csr: int = 10) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Get generate over T2 spin-adapted operators in matrix form.

Parameters:

num_spin_orbs – Number of spin orbitals.
use_csr – Orbital limit for which sparse matrices will be used.

Returns:

T2 operator generator.

get_t3_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, int, int, OperatorPauli], None, None]

Get generate over T3 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T3 operator generator.

get_t4_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Get generate over T4 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T4 operator generator.

get_t5_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Get generate over T5 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T5 operator generator.

get_t6_generator(num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Get generate over T6 operators.

Parameters:: num_spin_orbs – Number of spin orbitals.
Returns:: T6 operator generator.

slowquant.unitary_coupled_cluster.util.construct_integral_trans_mat(c_orthonormal: ndarray, kappa: Sequence[float], kappa_idx: Sequence[Sequence[int]]) → ndarray

Contruct orbital transformation matrix.

Parameters:

c_orthonormal – Initial orbital coefficients.
kappa – Orbital rotation parameters.
kappa_idx – Non-redundant orbital rotation parameters indices.

Returns:

Orbital transformation matrix.

slowquant.unitary_coupled_cluster.util.construct_ucc_u(num_spin_orbs: int, theta: Sequence[float], theta_picker: ThetaPicker, excitations: str, allowed_states: ndarray | None = None, use_csr: int = 10) → ndarray

Contruct unitary transformation matrix.

Parameters:

num_spin_orbs – Number of spin orbitals.
theta – Active-space parameters. Ordered as (S, D, T, …).
theta_picker – Helper class to pick the parameters in the right order.
excitations – Excitation orders to include.
allowed_states – Allowed states to consider in the state-vector.
use_csr – Use sparse matrices after n spin orbitals.

Returns:

Unitary transformation matrix.

slowquant.unitary_coupled_cluster.util.iterate_t1(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Iterate over T1 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T1 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t1_sa(active_occ_idx: Sequence[int], active_unocc_idx: Sequence[int], num_spin_orbs: int) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Iterate over T1 spin-adapted operators.

Parameters:

active_occ_idx – Indices of strongly occupied orbitals.
active_unocc_idx – Indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.

Returns:

T1 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t1_sa_matrix(active_occ_idx: Sequence[int], active_unocc_idx: Sequence[int], num_spin_orbs: int, use_csr: int) → Generator[tuple[int, int, int, OperatorPauli], None, None]

Iterate over T1 spin-adapted operators in matrix form.

Parameters:

active_occ_idx – Indices of strongly occupied orbitals.
active_unocc_idx – Indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
use_csr – Use sparse matrices.

Returns:

T1 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t2(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Iterate over T2 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T2 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t2_sa(active_occ_idx: Sequence[int], active_unocc_idx: Sequence[int], num_spin_orbs: int) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Iterate over T2 spin-adapted operators.

Parameters:

active_occ_idx – Indices of strongly occupied orbitals.
active_unocc_idx – Indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.

Returns:

T2 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t2_sa_matrix(active_occ_idx: Sequence[int], active_unocc_idx: Sequence[int], num_spin_orbs: int, use_csr: int) → Generator[tuple[int, int, int, int, int, OperatorPauli], None, None]

Iterate over T2 spin-adapted operators in matrix form.

Parameters:

active_occ_idx – Indices of strongly occupied orbitals.
active_unocc_idx – Indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
use_csr – Use sparse matrices.

Returns:

T2 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t3(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, int, int, int, int, OperatorPauli], None, None]

Iterate over T3 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T3 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t4(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Iterate over T4 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T4 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t5(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Iterate over T5 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T5 operator iteration.

slowquant.unitary_coupled_cluster.util.iterate_t6(active_occ_spin_idx: list[int], active_unocc_spin_idx: list[int], num_spin_orbs: int, is_spin_conserving: bool) → Generator[tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, OperatorPauli], None, None]

Iterate over T6 operators.

Parameters:

active_occ_idx – Spin indices of strongly occupied orbitals.
active_unocc_idx – Spin indices of weakly occupied orbitals.
num_spin_orbs – Number of spin orbitals.
is_spin_conserving – Make spin conserving operators.

Returns:

T6 operator iteration.