From 742082d4ecb72f22fdaf396c8ea8f10b578387f9 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 08:24:33 +0100 Subject: [PATCH 1/8] Move EOM functions to EOM classes --- ebcc/cc/base.py | 234 ----------------------------------------------- ebcc/cc/gebcc.py | 142 ---------------------------- ebcc/cc/rebcc.py | 124 ------------------------- ebcc/cc/uebcc.py | 201 ---------------------------------------- ebcc/eom/base.py | 132 ++++++++++++-------------- ebcc/eom/geom.py | 154 +++++++++++++++++++++++++++++++ ebcc/eom/reom.py | 146 +++++++++++++++++++++++++++++ ebcc/eom/ueom.py | 201 ++++++++++++++++++++++++++++++++++++++++ 8 files changed, 558 insertions(+), 776 deletions(-) diff --git a/ebcc/cc/base.py b/ebcc/cc/base.py index be92c5ee..8c3cb531 100644 --- a/ebcc/cc/base.py +++ b/ebcc/cc/base.py @@ -782,168 +782,6 @@ def make_eb_coup_rdm( """ pass - def hbar_matvec_ip_intermediates( - self, - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ) -> Namespace[NDArray[float]]: - """Compute intermediates for the IP-EOM Hamiltonian. - - Args: - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - - Returns: - Intermediate products for the IP-EOM Hamiltonian. - """ - func, kwargs = self._load_function( - "hbar_matvec_ip_intermediates", - eris=eris, - amplitudes=amplitudes, - ) - res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) - return res - - def hbar_matvec_ip( - self, - excitations: Namespace[SpinArrayType], - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ints: Optional[Namespace[NDArray[float]]] = None, - ) -> Namespace[SpinArrayType]: - """Compute the product between a state vector and the IP-EOM Hamiltonian. - - Args: - excitations: State vector as a set of excitation amplitudes. - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - ints: Intermediate products. - - Returns: - Products between the state vectors and the IP-EOM Hamiltonian for the singles and - doubles. - """ - if not ints: - ints = self.hbar_matvec_ip_intermediates(eris=eris, amplitudes=amplitudes) - func, kwargs = self._load_function( - "hbar_matvec_ip", - eris=eris, - amplitudes=amplitudes, - excitations=excitations, - ints=ints, - ) - res: Namespace[SpinArrayType] = func(**kwargs) - res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) - return res - - def hbar_matvec_ea_intermediates( - self, - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ) -> Namespace[NDArray[float]]: - """Compute intermediates for the EA-EOM Hamiltonian. - - Args: - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - - Returns: - Intermediate products for the EA-EOM Hamiltonian. - """ - func, kwargs = self._load_function( - "hbar_matvec_ea_intermediates", - eris=eris, - amplitudes=amplitudes, - ) - res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) - return res - - def hbar_matvec_ea( - self, - excitations: Namespace[SpinArrayType], - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ints: Optional[Namespace[NDArray[float]]] = None, - ) -> Namespace[SpinArrayType]: - """Compute the product between a state vector and the EA-EOM Hamiltonian. - - Args: - excitations: State vector as a set of excitation amplitudes. - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - ints: Intermediate products. - - Returns: - Products between the state vectors and the EA-EOM Hamiltonian for the singles and - doubles. - """ - if not ints: - ints = self.hbar_matvec_ea_intermediates(eris=eris, amplitudes=amplitudes) - func, kwargs = self._load_function( - "hbar_matvec_ea", - eris=eris, - amplitudes=amplitudes, - excitations=excitations, - ints=ints, - ) - res: Namespace[SpinArrayType] = func(**kwargs) - res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) - return res - - def hbar_matvec_ee_intermediates( - self, - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ) -> Namespace[NDArray[float]]: - """Compute intermediates for the EE-EOM Hamiltonian. - - Args: - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - - Returns: - Intermediate products for the EE-EOM Hamiltonian. - """ - func, kwargs = self._load_function( - "hbar_matvec_ee_intermediates", - eris=eris, - amplitudes=amplitudes, - ) - res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) - return res - - def hbar_matvec_ee( - self, - excitations: Namespace[SpinArrayType], - eris: Optional[ERIsInputType] = None, - amplitudes: Optional[Namespace[SpinArrayType]] = None, - ints: Optional[Namespace[NDArray[float]]] = None, - ) -> Namespace[SpinArrayType]: - """Compute the product between a state vector and the EE-EOM Hamiltonian. - - Args: - excitations: State vector as a set of excitation amplitudes. - eris: Electron repulsion integrals. - amplitudes: Cluster amplitudes. - ints: Intermediate products. - - Returns: - Products between the state vectors and the EE-EOM Hamiltonian for the singles and - doubles. - """ - if not ints: - ints = self.hbar_matvec_ee_intermediates(eris=eris, amplitudes=amplitudes) - func, kwargs = self._load_function( - "hbar_matvec_ee", - eris=eris, - amplitudes=amplitudes, - excitations=excitations, - ints=ints, - ) - res: Namespace[SpinArrayType] = func(**kwargs) - res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) - return res - @abstractmethod def energy_sum(self, *args: str, signs_dict: Optional[dict[str, str]] = None) -> NDArray[float]: """Get a direct sum of energies. @@ -1006,78 +844,6 @@ def vector_to_lambdas(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: """ pass - @abstractmethod - def excitations_to_vector_ip(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the IP-EOM excitations. - - Args: - excitations: IP-EOM excitations. - - Returns: - IP-EOM excitations as a vector. - """ - pass - - @abstractmethod - def excitations_to_vector_ea(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EA-EOM excitations. - - Args: - excitations: EA-EOM excitations. - - Returns: - EA-EOM excitations as a vector. - """ - pass - - @abstractmethod - def excitations_to_vector_ee(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EE-EOM excitations. - - Args: - excitations: EE-EOM excitations. - - Returns: - EE-EOM excitations as a vector. - """ - pass - - @abstractmethod - def vector_to_excitations_ip(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of IP-EOM excitations from a vector. - - Args: - vector: IP-EOM excitations as a vector. - - Returns: - IP-EOM excitations. - """ - pass - - @abstractmethod - def vector_to_excitations_ea(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EA-EOM excitations from a vector. - - Args: - vector: EA-EOM excitations as a vector. - - Returns: - EA-EOM excitations. - """ - pass - - @abstractmethod - def vector_to_excitations_ee(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EE-EOM excitations from a vector. - - Args: - vector: EE-EOM excitations as a vector. - - Returns: - EE-EOM excitations. - """ - pass - @property def fermion_ansatz(self) -> str: """Get a string representation of the fermion ansatz.""" diff --git a/ebcc/cc/gebcc.py b/ebcc/cc/gebcc.py index 422e2f66..bf607e84 100644 --- a/ebcc/cc/gebcc.py +++ b/ebcc/cc/gebcc.py @@ -803,148 +803,6 @@ def vector_to_lambdas(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: return lambdas - def excitations_to_vector_ip(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the IP-EOM excitations. - - Args: - excitations: IP-EOM excitations. - - Returns: - IP-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[:-1] - vectors.append(util.compress_axes(key, excitations[f"r{n}"]).ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def excitations_to_vector_ea(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EA-EOM excitations. - - Args: - excitations: EA-EOM excitations. - - Returns: - EA-EOM excitations as a vector. - """ - return self.excitations_to_vector_ip(excitations) - - def excitations_to_vector_ee(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EE-EOM excitations. - - Args: - excitations: EE-EOM excitations. - - Returns: - EE-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - vectors.append(util.compress_axes(key, excitations[f"r{n}"]).ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def vector_to_excitations_ip(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of IP-EOM excitations from a vector. - - Args: - vector: IP-EOM excitations as a vector. - - Returns: - IP-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[:-1] - size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) - shape = tuple(self.space.size(k) for k in key) - vn_tril = vector[i0 : i0 + size] - vn = util.decompress_axes(key, vn_tril, shape=shape) - excitations[f"r{n}"] = vn - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - - def vector_to_excitations_ea(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EA-EOM excitations from a vector. - - Args: - vector: EA-EOM excitations as a vector. - - Returns: - EA-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[n:] + key[: n - 1] - size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) - shape = tuple(self.space.size(k) for k in key) - vn_tril = vector[i0 : i0 + size] - vn = util.decompress_axes(key, vn_tril, shape=shape) - excitations[f"r{n}"] = vn - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - - def vector_to_excitations_ee(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EE-EOM excitations from a vector. - - Args: - vector: EE-EOM excitations as a vector. - - Returns: - EE-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) - shape = tuple(self.space.size(k) for k in key) - vn_tril = vector[i0 : i0 + size] - vn = util.decompress_axes(key, vn_tril, shape=shape) - excitations[f"r{n}"] = vn - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - def get_mean_field_G(self) -> NDArray[float]: """Get the mean-field boson non-conserving term. diff --git a/ebcc/cc/rebcc.py b/ebcc/cc/rebcc.py index 26286465..474754af 100644 --- a/ebcc/cc/rebcc.py +++ b/ebcc/cc/rebcc.py @@ -579,130 +579,6 @@ def vector_to_lambdas(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: return lambdas - def excitations_to_vector_ip(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the IP-EOM excitations. - - Args: - excitations: IP-EOM excitations. - - Returns: - IP-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - vectors.append(excitations[f"r{n}"].ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def excitations_to_vector_ea(self, *excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EA-EOM excitations. - - Args: - excitations: EA-EOM excitations. - - Returns: - EA-EOM excitations as a vector. - """ - return self.excitations_to_vector_ip(*excitations) - - def excitations_to_vector_ee(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EE-EOM excitations. - - Args: - excitations: EE-EOM excitations. - - Returns: - EE-EOM excitations as a vector. - """ - return self.excitations_to_vector_ip(excitations) - - def vector_to_excitations_ip(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of IP-EOM excitations from a vector. - - Args: - vector: IP-EOM excitations as a vector. - - Returns: - IP-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[:-1] - shape = tuple(self.space.size(k) for k in key) - size = np.prod(shape) - excitations[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - - def vector_to_excitations_ea(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EA-EOM excitations from a vector. - - Args: - vector: EA-EOM excitations as a vector. - - Returns: - EA-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[n:] + key[: n - 1] - shape = tuple(self.space.size(k) for k in key) - size = np.prod(shape) - excitations[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - - def vector_to_excitations_ee(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EE-EOM excitations from a vector. - - Args: - vector: EE-EOM excitations as a vector. - - Returns: - EE-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - shape = tuple(self.space.size(k) for k in key) - size = np.prod(shape) - excitations[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) - i0 += size - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return excitations - def get_mean_field_G(self) -> NDArray[float]: """Get the mean-field boson non-conserving term. diff --git a/ebcc/cc/uebcc.py b/ebcc/cc/uebcc.py index 532d40a1..3cbdbe21 100644 --- a/ebcc/cc/uebcc.py +++ b/ebcc/cc/uebcc.py @@ -769,207 +769,6 @@ def vector_to_lambdas(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: return lambdas - def excitations_to_vector_ip(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the IP-EOM excitations. - - Args: - excitations: IP-EOM excitations. - - Returns: - IP-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - for spin in util.generate_spin_combinations(n, excited=True, unique=True): - vn = excitations[f"r{n}"][spin] - subscript, _ = util.combine_subscripts(key[:-1], spin) - vectors.append(util.compress_axes(subscript, vn).ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def excitations_to_vector_ea(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EA-EOM excitations. - - Args: - excitations: EA-EOM excitations. - - Returns: - EA-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[n:] + key[:n] - for spin in util.generate_spin_combinations(n, excited=True, unique=True): - vn = excitations[f"r{n}"][spin] - subscript, _ = util.combine_subscripts(key[:-1], spin) - vectors.append(util.compress_axes(subscript, vn).ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def excitations_to_vector_ee(self, excitations: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the EE-EOM excitations. - - Args: - excitations: EE-EOM excitations. - - Returns: - EE-EOM excitations as a vector. - """ - vectors = [] - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - for spin in util.generate_spin_combinations(n): - vn = excitations[f"r{n}"][spin] - subscript, _ = util.combine_subscripts(key, spin) - vectors.append(util.compress_axes(subscript, vn).ravel()) - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - return np.concatenate(vectors) - - def vector_to_excitations_ip(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of IP-EOM excitations from a vector. - - Args: - vector: IP-EOM excitations as a vector. - - Returns: - IP-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - sizes: dict[tuple[str, ...], int] = { - (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") - } - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[:-1] - amp: SpinArrayType = util.Namespace() - for spin in util.generate_spin_combinations(n, excited=True, unique=True): - subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) - size = util.get_compressed_size(subscript, **csizes) - shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) - vn_tril = vector[i0 : i0 + size] - factor = max( - spin[:n].count(s) for s in set(spin[:n]) - ) # FIXME why? untested for n > 2 - vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor - amp[spin] = vn - i0 += size - - excitations[f"r{n}"] = amp - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - assert i0 == len(vector) - - return excitations - - def vector_to_excitations_ea(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EA-EOM excitations from a vector. - - Args: - vector: EA-EOM excitations as a vector. - - Returns: - EA-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - sizes: dict[tuple[str, ...], int] = { - (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") - } - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - key = key[n:] + key[: n - 1] - amp: SpinArrayType = util.Namespace() - for spin in util.generate_spin_combinations(n, excited=True, unique=True): - subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) - size = util.get_compressed_size(subscript, **csizes) - shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) - vn_tril = vector[i0 : i0 + size] - factor = max( - spin[:n].count(s) for s in set(spin[:n]) - ) # FIXME why? untested for n > 2 - vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor - amp[spin] = vn - i0 += size - - excitations[f"r{n}"] = amp - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - assert i0 == len(vector) - - return excitations - - def vector_to_excitations_ee(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct a namespace of EE-EOM excitations from a vector. - - Args: - vector: EE-EOM excitations as a vector. - - Returns: - EE-EOM excitations. - """ - excitations: Namespace[SpinArrayType] = util.Namespace() - i0 = 0 - sizes: dict[tuple[str, ...], int] = { - (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") - } - - for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): - amp: SpinArrayType = util.Namespace() - for spin in util.generate_spin_combinations(n): - subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) - size = util.get_compressed_size(subscript, **csizes) - shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) - vn_tril = vector[i0 : i0 + size] - factor = max( - spin[:n].count(s) for s in set(spin[:n]) - ) # FIXME why? untested for n > 2 - vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor - amp[spin] = vn - i0 += size - - excitations[f"r{n}"] = amp - - for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): - raise util.ModelNotImplemented - - assert i0 == len(vector) - - return excitations - def get_mean_field_G(self) -> NDArray[float]: """Get the mean-field boson non-conserving term. diff --git a/ebcc/eom/base.py b/ebcc/eom/base.py index 46d55ebd..b8be6346 100644 --- a/ebcc/eom/base.py +++ b/ebcc/eom/base.py @@ -363,28 +363,6 @@ def excitation_type(self) -> str: """Get the type of excitation.""" return "ip" - def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the amplitudes used in the given ansatz. - - Args: - amplitudes: Cluster amplitudes. - - Returns: - Cluster amplitudes as a vector. - """ - return self.ebcc.excitations_to_vector_ip(amplitudes) - - def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct amplitudes from a vector. - - Args: - vector: Cluster amplitudes as a vector. - - Returns: - Cluster amplitudes. - """ - return self.ebcc.vector_to_excitations_ip(vector) - def matvec( self, vector: NDArray[float], @@ -401,9 +379,19 @@ def matvec( Returns: Resulting vector. """ + if not ints: + ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) - result = self.ebcc.hbar_matvec_ip(amplitudes, eris=eris, ints=ints) - return self.amplitudes_to_vector(result) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ip", + eris=eris, + ints=ints, + amplitudes=self.ebcc.amplitudes, + excitations=amplitudes, + ) + res: Namespace[SpinArrayType] = func(**kwargs) + res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) + return self.amplitudes_to_vector(res) def matvec_intermediates( self, eris: Optional[ERIsInputType] = None @@ -416,7 +404,13 @@ def matvec_intermediates( Returns: Intermediate products. """ - return self.ebcc.hbar_matvec_ip_intermediates(eris=eris) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ip_intermediates", + eris=eris, + amplitudes=self.ebcc.amplitudes, + ) + res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) + return res class BaseEA_EOM(BaseEOM): @@ -427,28 +421,6 @@ def excitation_type(self) -> str: """Get the type of excitation.""" return "ea" - def amplitudes_to_vector(self, amplitudes: SpinArrayType) -> NDArray[float]: - """Construct a vector containing all of the amplitudes used in the given ansatz. - - Args: - amplitudes: Cluster amplitudes. - - Returns: - Cluster amplitudes as a vector. - """ - return self.ebcc.excitations_to_vector_ea(amplitudes) - - def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct amplitudes from a vector. - - Args: - vector: Cluster amplitudes as a vector. - - Returns: - Cluster amplitudes. - """ - return self.ebcc.vector_to_excitations_ea(vector) - def matvec( self, vector: NDArray[float], @@ -465,9 +437,19 @@ def matvec( Returns: Resulting vector. """ + if not ints: + ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) - result = self.ebcc.hbar_matvec_ea(amplitudes, eris=eris, ints=ints) - return self.amplitudes_to_vector(result) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ea", + eris=eris, + ints=ints, + amplitudes=self.ebcc.amplitudes, + excitations=amplitudes, + ) + res: Namespace[SpinArrayType] = func(**kwargs) + res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) + return self.amplitudes_to_vector(res) def matvec_intermediates( self, eris: Optional[ERIsInputType] = None @@ -480,7 +462,13 @@ def matvec_intermediates( Returns: Intermediate products. """ - return self.ebcc.hbar_matvec_ea_intermediates(eris=eris) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ea_intermediates", + eris=eris, + amplitudes=self.ebcc.amplitudes, + ) + res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) + return res class BaseEE_EOM(BaseEOM): @@ -491,28 +479,6 @@ def excitation_type(self) -> str: """Get the type of excitation.""" return "ee" - def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: - """Construct a vector containing all of the amplitudes used in the given ansatz. - - Args: - amplitudes: Cluster amplitudes. - - Returns: - Cluster amplitudes as a vector. - """ - return self.ebcc.excitations_to_vector_ee(amplitudes) - - def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: - """Construct amplitudes from a vector. - - Args: - vector: Cluster amplitudes as a vector. - - Returns: - Cluster amplitudes. - """ - return self.ebcc.vector_to_excitations_ee(vector) - def matvec( self, vector: NDArray[float], @@ -529,9 +495,19 @@ def matvec( Returns: Resulting vector. """ + if not ints: + ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) - result = self.ebcc.hbar_matvec_ee(amplitudes, eris=eris, ints=ints) - return self.amplitudes_to_vector(result) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ee", + eris=eris, + ints=ints, + amplitudes=self.ebcc.amplitudes, + excitations=amplitudes, + ) + res: Namespace[SpinArrayType] = func(**kwargs) + res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()}) + return self.amplitudes_to_vector(res) def matvec_intermediates( self, eris: Optional[ERIsInputType] = None @@ -544,4 +520,10 @@ def matvec_intermediates( Returns: Intermediate products. """ - return self.ebcc.hbar_matvec_ee_intermediates(eris=eris) + func, kwargs = self.ebcc._load_function( + "hbar_matvec_ee_intermediates", + eris=eris, + amplitudes=self.ebcc.amplitudes, + ) + res: Namespace[NDArray[float]] = util.Namespace(**func(**kwargs)) + return res diff --git a/ebcc/eom/geom.py b/ebcc/eom/geom.py index 67b2fa31..0ff784c5 100644 --- a/ebcc/eom/geom.py +++ b/ebcc/eom/geom.py @@ -63,6 +63,58 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the IP-EOM amplitudes. + + Args: + amplitudes: IP-EOM amplitudes. + + Returns: + IP-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[:-1] + vectors.append(util.compress_axes(key, amplitudes[f"r{n}"]).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of IP-EOM amplitudes from a vector. + + Args: + vector: IP-EOM amplitudes as a vector. + + Returns: + IP-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[:-1] + size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) + shape = tuple(self.space.size(k) for k in key) + vn_tril = vector[i0 : i0 + size] + vn = util.decompress_axes(key, vn_tril, shape=shape) + amplitudes[f"r{n}"] = vn + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes + class EA_GEOM(GEOM, BaseEA_EOM): """Generalised electron affinity equation-of-motion coupled cluster.""" @@ -101,6 +153,58 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EA-EOM amplitudes. + + Args: + amplitudes: EA-EOM amplitudes. + + Returns: + EA-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[:-1] + vectors.append(util.compress_axes(key, amplitudes[f"r{n}"]).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EA-EOM amplitudes from a vector. + + Args: + vector: EA-EOM amplitudes as a vector. + + Returns: + EA-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[n:] + key[: n - 1] + size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) + shape = tuple(self.space.size(k) for k in key) + vn_tril = vector[i0 : i0 + size] + vn = util.decompress_axes(key, vn_tril, shape=shape) + amplitudes[f"r{n}"] = vn + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes + class EE_GEOM(GEOM, BaseEE_EOM): """Generalised electron-electron equation-of-motion coupled cluster.""" @@ -137,3 +241,53 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: raise util.ModelNotImplemented return self.amplitudes_to_vector(parts) + + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EE-EOM amplitudes. + + Args: + amplitudes: EE-EOM amplitudes. + + Returns: + EE-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + vectors.append(util.compress_axes(key, amplitudes[f"r{n}"]).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EE-EOM amplitudes from a vector. + + Args: + vector: EE-EOM amplitudes as a vector. + + Returns: + EE-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + size = util.get_compressed_size(key, **{k: self.space.size(k) for k in set(key)}) + shape = tuple(self.space.size(k) for k in key) + vn_tril = vector[i0 : i0 + size] + vn = util.decompress_axes(key, vn_tril, shape=shape) + amplitudes[f"r{n}"] = vn + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes diff --git a/ebcc/eom/reom.py b/ebcc/eom/reom.py index f9159fa7..a6b1dafe 100644 --- a/ebcc/eom/reom.py +++ b/ebcc/eom/reom.py @@ -63,6 +63,55 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the IP-EOM amplitudes. + + Args: + amplitudes: IP-EOM amplitudes. + + Returns: + IP-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + vectors.append(amplitudes[f"r{n}"].ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of IP-EOM amplitudes from a vector. + + Args: + vector: IP-EOM amplitudes as a vector. + + Returns: + IP-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[:-1] + shape = tuple(self.space.size(k) for k in key) + size = int(np.prod(shape)) + amplitudes[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes + class EA_REOM(REOM, BaseEA_EOM): """Restricted electron affinity equation-of-motion coupled cluster.""" @@ -101,6 +150,55 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EA-EOM amplitudes. + + Args: + amplitudes: EA-EOM amplitudes. + + Returns: + EA-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + vectors.append(amplitudes[f"r{n}"].ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EA-EOM amplitudes from a vector. + + Args: + vector: EA-EOM amplitudes as a vector. + + Returns: + EA-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[n:] + key[: n - 1] + shape = tuple(self.space.size(k) for k in key) + size = int(np.prod(shape)) + amplitudes[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes + class EE_REOM(REOM, BaseEE_EOM): """Restricted electron-electron equation-of-motion coupled cluster.""" @@ -137,3 +235,51 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: raise util.ModelNotImplemented return self.amplitudes_to_vector(parts) + + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EE-EOM amplitudes. + + Args: + amplitudes: EE-EOM amplitudes. + + Returns: + EE-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + vectors.append(amplitudes[f"r{n}"].ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EE-EOM amplitudes from a vector. + + Args: + vector: EE-EOM amplitudes as a vector. + + Returns: + EE-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + shape = tuple(self.space.size(k) for k in key) + size = int(np.prod(shape)) + amplitudes[f"r{n}"] = vector[i0 : i0 + size].reshape(shape) + i0 += size + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return amplitudes diff --git a/ebcc/eom/ueom.py b/ebcc/eom/ueom.py index 354f7250..cb7eb00f 100644 --- a/ebcc/eom/ueom.py +++ b/ebcc/eom/ueom.py @@ -66,6 +66,73 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the IP-EOM amplitudes. + + Args: + amplitudes: IP-EOM amplitudes. + + Returns: + IP-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + for spin in util.generate_spin_combinations(n, excited=True, unique=True): + vn = amplitudes[f"r{n}"][spin] + subscript, _ = util.combine_subscripts(key[:-1], spin) + vectors.append(util.compress_axes(subscript, vn).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of IP-EOM amplitudes from a vector. + + Args: + vector: IP-EOM amplitudes as a vector. + + Returns: + IP-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + sizes: dict[tuple[str, ...], int] = { + (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") + } + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[:-1] + amp: SpinArrayType = util.Namespace() + for spin in util.generate_spin_combinations(n, excited=True, unique=True): + subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) + size = util.get_compressed_size(subscript, **csizes) + shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) + vn_tril = vector[i0 : i0 + size] + factor = max( + spin[:n].count(s) for s in set(spin[:n]) + ) # FIXME why? untested for n > 2 + vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor + amp[spin] = vn + i0 += size + + amplitudes[f"r{n}"] = amp + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + assert i0 == len(vector) + + return amplitudes + class EA_UEOM(UEOM, BaseEA_EOM): """Unrestricted electron affinity equation-of-motion coupled cluster.""" @@ -107,6 +174,74 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: return self.amplitudes_to_vector(parts) + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EA-EOM amplitudes. + + Args: + amplitudes: EA-EOM amplitudes. + + Returns: + EA-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[n:] + key[:n] + for spin in util.generate_spin_combinations(n, excited=True, unique=True): + vn = amplitudes[f"r{n}"][spin] + subscript, _ = util.combine_subscripts(key[:-1], spin) + vectors.append(util.compress_axes(subscript, vn).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EA-EOM amplitudes from a vector. + + Args: + vector: EA-EOM amplitudes as a vector. + + Returns: + EA-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + sizes: dict[tuple[str, ...], int] = { + (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") + } + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + key = key[n:] + key[: n - 1] + amp: SpinArrayType = util.Namespace() + for spin in util.generate_spin_combinations(n, excited=True, unique=True): + subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) + size = util.get_compressed_size(subscript, **csizes) + shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) + vn_tril = vector[i0 : i0 + size] + factor = max( + spin[:n].count(s) for s in set(spin[:n]) + ) # FIXME why? untested for n > 2 + vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor + amp[spin] = vn + i0 += size + + amplitudes[f"r{n}"] = amp + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + assert i0 == len(vector) + + return amplitudes + class EE_UEOM(UEOM, BaseEE_EOM): """Unrestricted electron-electron equation-of-motion coupled cluster.""" @@ -146,3 +281,69 @@ def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[float]: raise util.ModelNotImplemented return self.amplitudes_to_vector(parts) + + def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[float]: + """Construct a vector containing all of the EE-EOM amplitudes. + + Args: + amplitudes: EE-EOM amplitudes. + + Returns: + EE-EOM amplitudes as a vector. + """ + vectors = [] + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + for spin in util.generate_spin_combinations(n): + vn = amplitudes[f"r{n}"][spin] + subscript, _ = util.combine_subscripts(key, spin) + vectors.append(util.compress_axes(subscript, vn).ravel()) + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + return np.concatenate(vectors) + + def vector_to_amplitudes(self, vector: NDArray[float]) -> Namespace[SpinArrayType]: + """Construct a namespace of EE-EOM amplitudes from a vector. + + Args: + vector: EE-EOM amplitudes as a vector. + + Returns: + EE-EOM amplitudes. + """ + amplitudes: Namespace[SpinArrayType] = util.Namespace() + i0 = 0 + sizes: dict[tuple[str, ...], int] = { + (o, s): self.space[i].size(o) for o in "ovOVia" for i, s in enumerate("ab") + } + + for name, key, n in self.ansatz.fermionic_cluster_ranks(spin_type=self.spin_type): + amp: SpinArrayType = util.Namespace() + for spin in util.generate_spin_combinations(n): + subscript, csizes = util.combine_subscripts(key, spin, sizes=sizes) + size = util.get_compressed_size(subscript, **csizes) + shape = tuple(self.space["ab".index(s)].size(k) for s, k in zip(spin, key)) + vn_tril = vector[i0 : i0 + size] + factor = max( + spin[:n].count(s) for s in set(spin[:n]) + ) # FIXME why? untested for n > 2 + vn = util.decompress_axes(subscript, vn_tril, shape=shape) / factor + amp[spin] = vn + i0 += size + + amplitudes[f"r{n}"] = amp + + for name, key, n in self.ansatz.bosonic_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + for name, key, nf, nb in self.ansatz.coupling_cluster_ranks(spin_type=self.spin_type): + raise util.ModelNotImplemented + + assert i0 == len(vector) + + return amplitudes From e7621d1e4da7cd81f0d57537ba0151f9ae214627 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 09:13:17 +0100 Subject: [PATCH 2/8] Support left-hand EOM functions --- ebcc/eom/base.py | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-) diff --git a/ebcc/eom/base.py b/ebcc/eom/base.py index b8be6346..5bbf5932 100644 --- a/ebcc/eom/base.py +++ b/ebcc/eom/base.py @@ -145,6 +145,7 @@ def matvec( vector: NDArray[float], eris: Optional[ERIsInputType] = None, ints: Optional[NDArray[float]] = None, + left: bool = False, ) -> NDArray[float]: """Apply the Hamiltonian to a vector. @@ -152,6 +153,7 @@ def matvec( vector: State vector to apply the Hamiltonian to. eris: Electronic repulsion integrals. ints: Intermediate products. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Resulting vector. @@ -160,12 +162,13 @@ def matvec( @abstractmethod def matvec_intermediates( - self, eris: Optional[ERIsInputType] = None + self, eris: Optional[ERIsInputType] = None, left: bool = False ) -> Namespace[NDArray[float]]: """Get the intermediates for application of the Hamiltonian to a vector. Args: eris: Electronic repulsion integrals. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Intermediate products. @@ -368,6 +371,7 @@ def matvec( vector: NDArray[float], eris: Optional[ERIsInputType] = None, ints: Optional[NDArray[float]] = None, + left: bool = False, ) -> NDArray[float]: """Apply the Hamiltonian to a vector. @@ -375,6 +379,7 @@ def matvec( vector: State vector to apply the Hamiltonian to. eris: Electronic repulsion integrals. ints: Intermediate products. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Resulting vector. @@ -383,7 +388,7 @@ def matvec( ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( - "hbar_matvec_ip", + f"hbar_{'l' if left else ''}matvec_ip", eris=eris, ints=ints, amplitudes=self.ebcc.amplitudes, @@ -394,18 +399,19 @@ def matvec( return self.amplitudes_to_vector(res) def matvec_intermediates( - self, eris: Optional[ERIsInputType] = None + self, eris: Optional[ERIsInputType] = None, left: bool = False ) -> Namespace[NDArray[float]]: """Get the intermediates for application of the Hamiltonian to a vector. Args: eris: Electronic repulsion integrals. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Intermediate products. """ func, kwargs = self.ebcc._load_function( - "hbar_matvec_ip_intermediates", + f"hbar_{'l' if left else ''}matvec_ip_intermediates", eris=eris, amplitudes=self.ebcc.amplitudes, ) @@ -426,6 +432,7 @@ def matvec( vector: NDArray[float], eris: Optional[ERIsInputType] = None, ints: Optional[NDArray[float]] = None, + left: bool = False, ) -> NDArray[float]: """Apply the Hamiltonian to a vector. @@ -433,6 +440,7 @@ def matvec( vector: State vector to apply the Hamiltonian to. eris: Electronic repulsion integrals. ints: Intermediate products. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Resulting vector. @@ -441,7 +449,7 @@ def matvec( ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( - "hbar_matvec_ea", + f"hbar_{'l' if left else ''}matvec_ea", eris=eris, ints=ints, amplitudes=self.ebcc.amplitudes, @@ -452,18 +460,19 @@ def matvec( return self.amplitudes_to_vector(res) def matvec_intermediates( - self, eris: Optional[ERIsInputType] = None + self, eris: Optional[ERIsInputType] = None, left: bool = False ) -> Namespace[NDArray[float]]: """Get the intermediates for application of the Hamiltonian to a vector. Args: eris: Electronic repulsion integrals. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Intermediate products. """ func, kwargs = self.ebcc._load_function( - "hbar_matvec_ea_intermediates", + f"hbar_{'l' if left else ''}matvec_ea_intermediates", eris=eris, amplitudes=self.ebcc.amplitudes, ) @@ -484,6 +493,7 @@ def matvec( vector: NDArray[float], eris: Optional[ERIsInputType] = None, ints: Optional[NDArray[float]] = None, + left: bool = False, ) -> NDArray[float]: """Apply the Hamiltonian to a vector. @@ -491,6 +501,7 @@ def matvec( vector: State vector to apply the Hamiltonian to. eris: Electronic repulsion integrals. ints: Intermediate products. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Resulting vector. @@ -499,7 +510,7 @@ def matvec( ints = self.matvec_intermediates(eris=eris) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( - "hbar_matvec_ee", + f"hbar_{'l' if left else ''}matvec_ee", eris=eris, ints=ints, amplitudes=self.ebcc.amplitudes, @@ -510,18 +521,19 @@ def matvec( return self.amplitudes_to_vector(res) def matvec_intermediates( - self, eris: Optional[ERIsInputType] = None + self, eris: Optional[ERIsInputType] = None, left: bool = False ) -> Namespace[NDArray[float]]: """Get the intermediates for application of the Hamiltonian to a vector. Args: eris: Electronic repulsion integrals. + left: Whether to apply the left-hand side of the Hamiltonian. Returns: Intermediate products. """ func, kwargs = self.ebcc._load_function( - "hbar_matvec_ee_intermediates", + f"hbar_{'l' if left else ''}matvec_ee_intermediates", eris=eris, amplitudes=self.ebcc.amplitudes, ) From 257e682edbf200ddf071da97003465901c452ee5 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 09:14:20 +0100 Subject: [PATCH 3/8] Add option for left-hand EOM --- ebcc/eom/base.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ebcc/eom/base.py b/ebcc/eom/base.py index 5bbf5932..400f88ef 100644 --- a/ebcc/eom/base.py +++ b/ebcc/eom/base.py @@ -37,6 +37,7 @@ class BaseOptions: max_iter: Maximum number of iterations. max_space: Maximum size of the Lanczos vector space. koopmans: Whether to use a Koopmans'-like guess. + left: Whether to apply the left-hand side of the Hamiltonian. """ nroots: int = 5 @@ -44,6 +45,7 @@ class BaseOptions: max_iter: int = 100 max_space: int = 12 koopmans: bool = False + left: bool = False class BaseEOM(ABC): @@ -284,8 +286,8 @@ def davidson( ) # Get the matrix-vector products and the diagonal: - ints = self.matvec_intermediates(eris=eris) - matvecs = lambda vs: [self.matvec(v, eris=eris, ints=ints) for v in vs] + ints = self.matvec_intermediates(eris=eris, left=self.options.left) + matvecs = lambda vs: [self.matvec(v, eris=eris, ints=ints, left=self.options.left) for v in vs] diag = self.diag(eris=eris) # Get the guesses: From 14f47ae272241d4d6bf8d798811de3b4ad570353 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 21:54:03 +0100 Subject: [PATCH 4/8] Fix for left when no ints --- ebcc/eom/base.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ebcc/eom/base.py b/ebcc/eom/base.py index 400f88ef..437b82d3 100644 --- a/ebcc/eom/base.py +++ b/ebcc/eom/base.py @@ -387,7 +387,7 @@ def matvec( Resulting vector. """ if not ints: - ints = self.matvec_intermediates(eris=eris) + ints = self.matvec_intermediates(eris=eris, left=left) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( f"hbar_{'l' if left else ''}matvec_ip", @@ -448,7 +448,7 @@ def matvec( Resulting vector. """ if not ints: - ints = self.matvec_intermediates(eris=eris) + ints = self.matvec_intermediates(eris=eris, left=left) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( f"hbar_{'l' if left else ''}matvec_ea", @@ -509,7 +509,7 @@ def matvec( Resulting vector. """ if not ints: - ints = self.matvec_intermediates(eris=eris) + ints = self.matvec_intermediates(eris=eris, left=left) amplitudes = self.vector_to_amplitudes(vector) func, kwargs = self.ebcc._load_function( f"hbar_{'l' if left else ''}matvec_ee", From 8e3e6b7719fe463d9fd09c90d87a35ed8cb570c0 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 22:10:22 +0100 Subject: [PATCH 5/8] Add left EOM tests --- tests/test_GCCSD.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/test_GCCSD.py b/tests/test_GCCSD.py index dddfc9ab..057d0b9d 100644 --- a/tests/test_GCCSD.py +++ b/tests/test_GCCSD.py @@ -368,6 +368,21 @@ def test_eom_ea_koopmans(self): e2, v2 = self.ccsd_ref.eaccsd(nroots=5) self.assertAlmostEqual(e1[0], e2[0], 5) + def test_eom_ip_left(self): + e1 = self.ccsd.ip_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.ipccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ea_left(self): + e1 = self.ccsd.ea_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eaccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ee_left(self): + e1 = self.ccsd.ee_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eeccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + def test_rdm_energy(self): dm1 = self.ccsd.make_rdm1_f() dm2 = self.ccsd.make_rdm2_f() From c16ab351af21f450557a65e6bea467978c7c5600 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 22:20:27 +0100 Subject: [PATCH 6/8] Fix left EE-EOM test --- tests/test_GCCSD.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_GCCSD.py b/tests/test_GCCSD.py index 057d0b9d..f020ce7a 100644 --- a/tests/test_GCCSD.py +++ b/tests/test_GCCSD.py @@ -380,7 +380,7 @@ def test_eom_ea_left(self): def test_eom_ee_left(self): e1 = self.ccsd.ee_eom(nroots=5, left=True).kernel() - e2, v2 = self.ccsd_ref.eeccsd(nroots=5, left=True) + e2, v2 = self.ccsd_ref.eeccsd(nroots=5) # No left EE-EOM in PySCF self.assertAlmostEqual(e1[0], e2[0], 5) def test_rdm_energy(self): From c940f38f510ae5611849a9bad478e21abe6b1a60 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 22:39:05 +0100 Subject: [PATCH 7/8] Left-side EOM done --- ebcc/codegen/GCCSD.py | 2534 +++++++++++++++++++----------- ebcc/codegen/RCCSD.py | 631 ++++++++ ebcc/codegen/UCCSD.py | 3393 +++++++++++++++++++++++++++++++++++++++++ tests/test_RCCSD.py | 24 + tests/test_UCCSD.py | 30 + 5 files changed, 5704 insertions(+), 908 deletions(-) diff --git a/ebcc/codegen/GCCSD.py b/ebcc/codegen/GCCSD.py index e9425021..8c97dc00 100644 --- a/ebcc/codegen/GCCSD.py +++ b/ebcc/codegen/GCCSD.py @@ -2,7 +2,7 @@ Code generated by `albert`: https://github.com/obackhouse/albert - * date: 2024-08-12T21:47:30.035000 + * date: 2024-08-13T22:13:05.368573 * python version: 3.10.12 (main, Jul 29 2024, 16:56:48) [GCC 11.4.0] * albert version: 0.0.0 * caller: /home/ollie/git/albert/albert/codegen/einsum.py @@ -18,7 +18,7 @@ def energy(f=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:30.201242. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:05.515420. Parameters ---------- @@ -38,16 +38,16 @@ def energy(f=None, t1=None, t2=None, v=None, **kwargs): """ tmp0 = t2.copy() - tmp0 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * 2 - e_cc = einsum(tmp0, (0, 1, 2, 3), v.oovv, (0, 1, 2, 3), ()) * 0.25 + tmp0 += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) * 2 + e_cc = einsum(t1, (0, 1), f.ov, (0, 1), ()) + e_cc += einsum(v.oovv, (0, 1, 2, 3), tmp0, (0, 1, 2, 3), ()) * 0.25 del tmp0 - e_cc += einsum(f.ov, (0, 1), t1, (0, 1), ()) return e_cc def update_amps(f=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:34.832884. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:09.825415. Parameters ---------- @@ -68,167 +68,166 @@ def update_amps(f=None, t1=None, t2=None, v=None, **kwargs): Updated T2 residuals. """ - tmp17 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) - tmp16 = einsum(f.ov, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) - tmp3 = einsum(v.oovv, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp21 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp20 = einsum(t2, (0, 1, 2, 3), f.ov, (4, 3), (4, 0, 1, 2)) + tmp3 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp18 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp22 = tmp20.transpose((0, 2, 1, 3)).copy() * -1 + del tmp20 + tmp22 += tmp21.transpose((2, 1, 0, 3)) * 0.5 + del tmp21 + tmp11 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) + tmp13 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp15 = einsum(tmp3, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + tmp42 = t2.copy() + tmp42 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 + tmp40 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) tmp5 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) - tmp22 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) - tmp24 = einsum(v.ooov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp28 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 2, 3), (4, 0)) tmp7 = t2.copy() - tmp7 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * 2 - tmp32 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp14 = einsum(t2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp18 = tmp16.transpose((0, 2, 1, 3)).copy() * -1 - del tmp16 - tmp18 += tmp17.transpose((2, 1, 0, 3)) * 0.5 - del tmp17 - tmp34 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) - tmp38 = einsum(tmp3, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 - tmp36 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp7 += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) * 2 + tmp30 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) tmp0 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp9 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) - tmp11 = t2.copy() - tmp11 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 + tmp9 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) tmp6 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) - tmp29 = einsum(tmp3, (0, 1), t1, (2, 1), (2, 0)) - tmp21 = einsum(t2, (0, 1, 2, 3), tmp5, (1, 4), (4, 0, 2, 3)) - tmp23 = einsum(t2, (0, 1, 2, 3), tmp22, (4, 1), (0, 4, 2, 3)) - del tmp22 - tmp25 = einsum(tmp7, (0, 1, 2, 3), tmp24, (4, 0, 1, 5), (4, 5, 2, 3)) * 0.5 - del tmp24 - tmp41 = einsum(tmp32, (0, 1, 2, 3), t1, (4, 3), (0, 4, 1, 2)) * -1 - tmp15 = einsum(tmp14, (0, 1), t2, (2, 3, 4, 1), (2, 3, 4, 0)) - del tmp14 - tmp19 = einsum(tmp18, (0, 1, 2, 3), t1, (0, 4), (1, 2, 3, 4)) + tmp37 = einsum(t1, (0, 1), tmp3, (2, 1), (0, 2)) + tmp19 = einsum(tmp18, (0, 1), t2, (2, 3, 4, 1), (2, 3, 4, 0)) del tmp18 - tmp35 = einsum(t2, (0, 1, 2, 3), tmp34, (4, 3), (0, 1, 2, 4)) * -1 - del tmp34 - tmp39 = einsum(tmp38, (0, 1, 2, 3), t1, (2, 4), (0, 1, 4, 3)) - del tmp38 - tmp37 = einsum(t2, (0, 1, 2, 3), tmp36, (4, 1, 5, 3), (4, 0, 5, 2)) - del tmp36 - tmp43 = einsum(t1, (0, 1), v.ooov, (2, 3, 0, 4), (2, 3, 1, 4)) - tmp44 = einsum(t2, (0, 1, 2, 3), f.vv, (4, 3), (0, 1, 4, 2)) - tmp47 = einsum(tmp0, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) - tmp10 = einsum(t1, (0, 1), tmp9, (2, 0, 3, 4), (2, 3, 1, 4)) - del tmp9 - tmp12 = einsum(v.ovov, (0, 1, 2, 3), tmp11, (2, 4, 1, 5), (4, 0, 5, 3)) + tmp23 = einsum(tmp22, (0, 1, 2, 3), t1, (0, 4), (1, 2, 3, 4)) + del tmp22 + tmp12 = einsum(tmp11, (0, 1), t2, (2, 3, 4, 1), (2, 3, 4, 0)) * -1 del tmp11 - tmp28 = einsum(t2, (0, 1, 2, 3), tmp6, (1, 4), (0, 4, 2, 3)) * -1 - tmp27 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 1), (4, 0, 2, 3)) - tmp30 = einsum(tmp29, (0, 1), t2, (2, 1, 3, 4), (0, 2, 3, 4)) * -1 - del tmp29 - tmp26 = tmp21.transpose((0, 1, 3, 2)).copy() - del tmp21 - tmp26 += tmp23.transpose((0, 1, 3, 2)) * -0.5 - del tmp23 - tmp26 += tmp25.transpose((0, 1, 3, 2)) * -1 - del tmp25 - t2new = tmp26.transpose((1, 0, 2, 3)).copy() - t2new += tmp26 * -1 - del tmp26 - tmp42 = einsum(t1, (0, 1), tmp41, (2, 3, 0, 4), (3, 2, 1, 4)) * -1 - del tmp41 - t2new += tmp42.transpose((0, 1, 3, 2)) - t2new += tmp42 * -1 - del tmp42 - tmp20 = tmp15.copy() * 0.5 + tmp14 = einsum(t2, (0, 1, 2, 3), tmp13, (4, 1, 5, 3), (0, 4, 2, 5)) + del tmp13 + tmp16 = einsum(t1, (0, 1), tmp15, (2, 3, 0, 4), (2, 3, 1, 4)) del tmp15 - tmp20 += tmp19.transpose((1, 0, 3, 2)) - del tmp19 - t2new += tmp20.transpose((0, 1, 3, 2)) - t2new += tmp20 * -1 - del tmp20 - tmp40 = tmp35.copy() - del tmp35 - tmp40 += tmp37 - del tmp37 - tmp40 += tmp39 * -1 - del tmp39 - t2new += tmp40.transpose((0, 1, 3, 2)) * -1 - t2new += tmp40 + tmp43 = einsum(tmp42, (0, 1, 2, 3), v.ovov, (4, 2, 0, 5), (1, 4, 3, 5)) + del tmp42 + tmp41 = einsum(t1, (0, 1), tmp40, (2, 0, 3, 4), (2, 3, 1, 4)) del tmp40 - tmp45 = tmp43.transpose((1, 0, 2, 3)).copy() * -1 - del tmp43 - tmp45 += tmp44.transpose((1, 0, 2, 3)) * -1 - del tmp44 - t2new += tmp45.transpose((0, 1, 3, 2)) - t2new += tmp45 * -1 - del tmp45 - tmp48 = einsum(t1, (0, 1), tmp47, (2, 3, 0, 4), (2, 3, 1, 4)) - del tmp47 - t2new += tmp48.transpose((1, 0, 3, 2)) * -1 - t2new += tmp48.transpose((1, 0, 2, 3)) - t2new += tmp48.transpose((0, 1, 3, 2)) - t2new += tmp48 * -1 - del tmp48 - tmp13 = tmp10.copy() - del tmp10 - tmp13 += tmp12 * -1 - del tmp12 - t2new += tmp13.transpose((1, 0, 3, 2)) - t2new += tmp13.transpose((1, 0, 2, 3)) * -1 - t2new += tmp13.transpose((0, 1, 3, 2)) * -1 - t2new += tmp13 - del tmp13 - tmp46 = einsum(f.oo, (0, 1), t2, (2, 1, 3, 4), (0, 2, 3, 4)) - t2new += tmp46.transpose((1, 0, 3, 2)) - t2new += tmp46.transpose((0, 1, 3, 2)) * -1 - del tmp46 - tmp33 = einsum(tmp32, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 5, 2)) * -1 - del tmp32 - t2new += tmp33.transpose((1, 0, 3, 2)) - t2new += tmp33.transpose((1, 0, 2, 3)) * -1 - t2new += tmp33.transpose((0, 1, 3, 2)) * -1 - t2new += tmp33 - del tmp33 + tmp27 = einsum(t2, (0, 1, 2, 3), tmp5, (1, 4), (4, 0, 2, 3)) + tmp29 = einsum(t2, (0, 1, 2, 3), tmp28, (4, 1), (0, 4, 2, 3)) + del tmp28 + tmp31 = einsum(tmp30, (0, 1, 2, 3), tmp7, (1, 2, 4, 5), (0, 3, 4, 5)) * 0.5 + del tmp30 + tmp33 = einsum(tmp0, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp45 = einsum(t1, (0, 1), v.ooov, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp46 = einsum(t2, (0, 1, 2, 3), f.vv, (4, 3), (0, 1, 4, 2)) + tmp25 = einsum(t1, (0, 1), tmp9, (2, 3, 4, 1), (2, 0, 3, 4)) * -1 + tmp35 = einsum(t1, (0, 1), v.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp36 = einsum(t2, (0, 1, 2, 3), tmp6, (1, 4), (0, 4, 2, 3)) * -1 + tmp38 = einsum(t2, (0, 1, 2, 3), tmp37, (4, 1), (4, 0, 2, 3)) * -1 + del tmp37 + tmp24 = tmp19.copy() * 0.5 + del tmp19 + tmp24 += tmp23.transpose((1, 0, 3, 2)) + del tmp23 tmp2 = t2.copy() * 0.5 - tmp2 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) - t2new += einsum(v.vvvv, (0, 1, 2, 3), tmp2, (4, 5, 2, 3), (5, 4, 0, 1)) * -1 - t1new = einsum(v.ovvv, (0, 1, 2, 3), tmp2, (0, 4, 2, 3), (4, 1)) - del tmp2 + tmp2 += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) + tmp17 = tmp12.copy() + del tmp12 + tmp17 += tmp14 + del tmp14 + tmp17 += tmp16 * -1 + del tmp16 tmp49 = v.oooo.copy() tmp49 += einsum(v.oovv, (0, 1, 2, 3), tmp7, (4, 5, 2, 3), (0, 1, 5, 4)) * -0.5 - t2new += einsum(tmp49, (0, 1, 2, 3), tmp7, (0, 1, 4, 5), (2, 3, 5, 4)) * -0.5 - del tmp49 - tmp31 = tmp27.transpose((0, 1, 3, 2)).copy() * -1 + tmp44 = tmp41.copy() + del tmp41 + tmp44 += tmp43 * -1 + del tmp43 + tmp32 = tmp27.transpose((0, 1, 3, 2)).copy() del tmp27 - tmp31 += tmp28.transpose((0, 1, 3, 2)) - del tmp28 - tmp31 += tmp30.transpose((0, 1, 3, 2)) * -1 - del tmp30 - t2new += tmp31.transpose((1, 0, 2, 3)) - t2new += tmp31 * -1 + tmp32 += tmp29.transpose((0, 1, 3, 2)) * -0.5 + del tmp29 + tmp32 += tmp31.transpose((0, 1, 3, 2)) * -1 del tmp31 - tmp4 = f.ov.copy() - tmp4 += tmp3 - del tmp3 - t1new += einsum(tmp4, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - del tmp4 - tmp1 = v.ovoo.transpose((0, 2, 3, 1)).copy() * -1 - tmp1 += tmp0.transpose((0, 2, 1, 3)) * -1 - del tmp0 - t1new += einsum(t2, (0, 1, 2, 3), tmp1, (4, 0, 1, 3), (4, 2)) * 0.5 - del tmp1 + tmp10 = einsum(tmp9, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 5, 2)) * -1 + del tmp9 + tmp34 = einsum(t1, (0, 1), tmp33, (2, 3, 0, 4), (2, 3, 1, 4)) + del tmp33 + tmp47 = tmp45.transpose((1, 0, 2, 3)).copy() * -1 + del tmp45 + tmp47 += tmp46.transpose((1, 0, 2, 3)) * -1 + del tmp46 + tmp26 = einsum(t1, (0, 1), tmp25, (2, 3, 0, 4), (3, 2, 1, 4)) * -1 + del tmp25 + tmp39 = tmp35.transpose((0, 1, 3, 2)).copy() * -1 + del tmp35 + tmp39 += tmp36.transpose((0, 1, 3, 2)) + del tmp36 + tmp39 += tmp38.transpose((0, 1, 3, 2)) * -1 + del tmp38 + tmp48 = einsum(t2, (0, 1, 2, 3), f.oo, (4, 1), (4, 0, 2, 3)) tmp8 = f.oo.copy() tmp8 += tmp5 del tmp5 tmp8 += tmp6 del tmp6 - tmp8 += einsum(tmp7, (0, 1, 2, 3), v.oovv, (4, 0, 2, 3), (4, 1)) * -0.5 - del tmp7 - t1new += einsum(t1, (0, 1), tmp8, (0, 2), (2, 1)) * -1 + tmp8 += einsum(v.oovv, (0, 1, 2, 3), tmp7, (1, 4, 2, 3), (0, 4)) * -0.5 + tmp1 = v.ovoo.transpose((0, 2, 3, 1)).copy() * -1 + tmp1 += tmp0.transpose((0, 2, 1, 3)) * -1 + del tmp0 + tmp4 = f.ov.copy() + tmp4 += tmp3 + del tmp3 + t2new = v.oovv.copy() + t2new += tmp10 + t2new += tmp10.transpose((0, 1, 3, 2)) * -1 + t2new += tmp10.transpose((1, 0, 2, 3)) * -1 + t2new += tmp10.transpose((1, 0, 3, 2)) + del tmp10 + t2new += tmp17 + t2new += tmp17.transpose((0, 1, 3, 2)) * -1 + del tmp17 + t2new += tmp24 * -1 + t2new += tmp24.transpose((0, 1, 3, 2)) + del tmp24 + t2new += tmp26 * -1 + t2new += tmp26.transpose((0, 1, 3, 2)) + del tmp26 + t2new += tmp32 * -1 + t2new += tmp32.transpose((1, 0, 2, 3)) + del tmp32 + t2new += tmp34 * -1 + t2new += tmp34.transpose((0, 1, 3, 2)) + t2new += tmp34.transpose((1, 0, 2, 3)) + t2new += tmp34.transpose((1, 0, 3, 2)) * -1 + del tmp34 + t2new += tmp39 * -1 + t2new += tmp39.transpose((1, 0, 2, 3)) + del tmp39 + t2new += tmp44 + t2new += tmp44.transpose((0, 1, 3, 2)) * -1 + t2new += tmp44.transpose((1, 0, 2, 3)) * -1 + t2new += tmp44.transpose((1, 0, 3, 2)) + del tmp44 + t2new += tmp47 * -1 + t2new += tmp47.transpose((0, 1, 3, 2)) + del tmp47 + t2new += tmp48.transpose((0, 1, 3, 2)) * -1 + t2new += tmp48.transpose((1, 0, 3, 2)) + del tmp48 + t2new += einsum(tmp7, (0, 1, 2, 3), tmp49, (0, 1, 4, 5), (4, 5, 3, 2)) * -0.5 + del tmp7, tmp49 + t2new += einsum(tmp2, (0, 1, 2, 3), v.vvvv, (4, 5, 2, 3), (1, 0, 4, 5)) * -1 + t1new = f.ov.copy() + t1new += einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) * -1 + t1new += einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + t1new += einsum(t2, (0, 1, 2, 3), tmp1, (4, 0, 1, 3), (4, 2)) * 0.5 + del tmp1 + t1new += einsum(v.ovvv, (0, 1, 2, 3), tmp2, (0, 4, 2, 3), (4, 1)) + del tmp2 + t1new += einsum(tmp4, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + del tmp4 + t1new += einsum(tmp8, (0, 1), t1, (0, 2), (1, 2)) * -1 del tmp8 - t1new += f.ov - t1new += einsum(t1, (0, 1), f.vv, (2, 1), (0, 2)) - t1new += einsum(v.ovov, (0, 1, 2, 3), t1, (2, 1), (0, 3)) * -1 - t2new += v.oovv return {f"t1new": t1new, f"t2new": t2new} def update_lams(f=None, l1=None, l2=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:41.458357. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:15.890862. Parameters ---------- @@ -253,216 +252,215 @@ def update_lams(f=None, l1=None, l2=None, t1=None, t2=None, v=None, **kwargs): Updated L2 residuals. """ - tmp26 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) - tmp27 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 2, 3), (4, 0)) - tmp20 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 0, 1), (2, 4)) - tmp19 = einsum(l1, (0, 1), t1, (2, 0), (1, 2)) - tmp4 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) tmp5 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp35 = einsum(t2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp24 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) - tmp0 = einsum(l2, (0, 1, 2, 3), t1, (4, 1), (2, 3, 4, 0)) - l2new = einsum(v.ovvv, (0, 1, 2, 3), tmp0, (4, 5, 0, 1), (2, 3, 4, 5)) - l1new = einsum(tmp4, (0, 1, 2, 3), tmp0, (4, 0, 1, 2), (3, 4)) - l1new += einsum(tmp0, (0, 1, 2, 3), v.ovov, (2, 3, 1, 4), (4, 0)) * -1 - tmp43 = tmp26.copy() * 2 - tmp43 += tmp27.transpose((1, 0)) - tmp23 = tmp19.copy() - tmp23 += tmp20 * 0.5 - l1new += einsum(tmp23, (0, 1), v.ooov, (2, 1, 0, 3), (3, 2)) - tmp40 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) - tmp7 = einsum(v.oovv, (0, 1, 2, 3), t1, (1, 3), (0, 2)) - tmp30 = v.ovov.transpose((0, 2, 3, 1)).copy() * -1 - tmp30 += tmp4 - tmp52 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp34 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp23 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) + tmp20 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 0, 1), (2, 4)) + tmp19 = einsum(t1, (0, 1), l1, (1, 2), (2, 0)) + tmp26 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) + tmp25 = einsum(v.ooov, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp1 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp2 = einsum(l2, (0, 1, 2, 3), t1, (4, 1), (2, 3, 4, 0)) tmp17 = einsum(t2, (0, 1, 2, 3), l2, (4, 3, 0, 1), (4, 2)) tmp6 = v.ovoo.transpose((0, 2, 3, 1)).copy() * -1 tmp6 += tmp5.transpose((0, 2, 1, 3)) * -1 - tmp36 = tmp24.copy() - tmp36 += tmp35 * 0.5 - del tmp35 + tmp35 = tmp23.copy() + tmp35 += tmp34 * 0.5 + del tmp34 + tmp45 = tmp19.copy() + tmp45 += tmp20 * 0.5 + tmp43 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp47 = tmp25.copy() * 2 + tmp47 += tmp26.transpose((1, 0)) + tmp39 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp29 = v.ovov.transpose((0, 2, 3, 1)).copy() * -1 + tmp29 += tmp1 + tmp7 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp4 = einsum(t1, (0, 1), tmp2, (2, 3, 4, 1), (3, 2, 4, 0)) + tmp3 = einsum(l2, (0, 1, 2, 3), t2, (4, 5, 0, 1), (2, 3, 4, 5)) + tmp10 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) tmp11 = v.ooov.copy() tmp11 += tmp5.transpose((2, 1, 0, 3)) * 0.5 - tmp10 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 5, 2, 3), (0, 1, 4, 5)) - tmp2 = einsum(tmp0, (0, 1, 2, 3), t1, (4, 3), (1, 0, 2, 4)) - l1new += einsum(tmp2, (0, 1, 2, 3), v.ooov, (2, 3, 1, 4), (4, 0)) * -0.5 - tmp1 = einsum(t2, (0, 1, 2, 3), l2, (2, 3, 4, 5), (4, 5, 0, 1)) - l1new += einsum(v.ovoo, (0, 1, 2, 3), tmp1, (4, 0, 3, 2), (1, 4)) * 0.25 - tmp44 = einsum(l2, (0, 1, 2, 3), tmp43, (4, 3), (4, 2, 0, 1)) * -0.5 + tmp32 = einsum(f.ov, (0, 1), tmp2, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp33 = einsum(v.oovv, (0, 1, 2, 3), tmp17, (4, 3), (0, 1, 4, 2)) * -1 + tmp37 = einsum(tmp6, (0, 1, 2, 3), l1, (4, 0), (1, 2, 3, 4)) + tmp36 = einsum(l2, (0, 1, 2, 3), tmp35, (1, 4), (2, 3, 4, 0)) * -1 + del tmp35 + tmp46 = einsum(tmp45, (0, 1), v.oovv, (2, 1, 3, 4), (0, 2, 3, 4)) * -1 + del tmp45 + tmp44 = einsum(tmp43, (0, 1), l2, (2, 3, 4, 1), (0, 4, 2, 3)) del tmp43 - tmp42 = einsum(tmp23, (0, 1), v.oovv, (2, 1, 3, 4), (0, 2, 3, 4)) * -1 - del tmp23 - tmp41 = einsum(tmp40, (0, 1), l2, (2, 3, 4, 1), (0, 4, 2, 3)) - del tmp40 - tmp56 = einsum(tmp7, (0, 1), t1, (2, 1), (2, 0)) - tmp47 = einsum(l1, (0, 1), v.ovvv, (2, 0, 3, 4), (1, 2, 3, 4)) - tmp46 = einsum(f.oo, (0, 1), l2, (2, 3, 4, 1), (0, 4, 2, 3)) - tmp31 = einsum(tmp30, (0, 1, 2, 3), l2, (4, 2, 5, 0), (1, 5, 3, 4)) - del tmp30 - tmp29 = einsum(tmp0, (0, 1, 2, 3), v.ooov, (4, 2, 1, 5), (0, 4, 3, 5)) - tmp53 = einsum(l2, (0, 1, 2, 3), tmp52, (3, 4, 1, 5), (2, 4, 0, 5)) - del tmp52 - tmp54 = einsum(tmp0, (0, 1, 2, 3), tmp5, (0, 4, 2, 5), (1, 4, 3, 5)) * -1 + tmp48 = einsum(tmp47, (0, 1), l2, (2, 3, 4, 1), (0, 4, 2, 3)) * -0.5 + del tmp47 + tmp41 = einsum(tmp5, (0, 1, 2, 3), tmp2, (0, 4, 2, 5), (4, 1, 5, 3)) * -1 del tmp5 - tmp49 = einsum(l2, (0, 1, 2, 3), f.vv, (4, 1), (2, 3, 4, 0)) - tmp50 = einsum(tmp7, (0, 1), tmp0, (2, 3, 0, 4), (2, 3, 4, 1)) - tmp33 = einsum(f.ov, (0, 1), tmp0, (2, 3, 0, 4), (2, 3, 1, 4)) - tmp34 = einsum(tmp17, (0, 1), v.oovv, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 - tmp38 = einsum(tmp6, (0, 1, 2, 3), l1, (4, 0), (1, 2, 3, 4)) - tmp37 = einsum(l2, (0, 1, 2, 3), tmp36, (1, 4), (2, 3, 4, 0)) * -1 - del tmp36 + tmp40 = einsum(l2, (0, 1, 2, 3), tmp39, (3, 4, 1, 5), (2, 4, 0, 5)) + del tmp39 + tmp28 = einsum(v.ooov, (0, 1, 2, 3), tmp2, (4, 2, 1, 5), (4, 0, 5, 3)) + tmp30 = einsum(l2, (0, 1, 2, 3), tmp29, (3, 4, 1, 5), (4, 2, 5, 0)) + del tmp29 + tmp52 = einsum(l2, (0, 1, 2, 3), f.vv, (4, 1), (2, 3, 4, 0)) + tmp53 = einsum(tmp7, (0, 1), tmp2, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp50 = einsum(t1, (0, 1), tmp7, (2, 1), (0, 2)) + tmp56 = einsum(v.ovvv, (0, 1, 2, 3), l1, (1, 4), (4, 0, 2, 3)) + tmp55 = einsum(l2, (0, 1, 2, 3), f.oo, (4, 3), (4, 2, 0, 1)) + tmp8 = f.ov.copy() + tmp8 += tmp7 tmp21 = tmp19.copy() * 2 del tmp19 tmp21 += tmp20 del tmp20 + tmp15 = tmp3.transpose((1, 0, 3, 2)).copy() * -0.5 + tmp15 += tmp4.transpose((0, 1, 3, 2)) tmp9 = v.ovov.transpose((0, 2, 1, 3)).copy() - tmp9 += tmp4.transpose((0, 1, 3, 2)) * -0.5 - del tmp4 + tmp9 += tmp1.transpose((0, 1, 3, 2)) * -0.5 tmp12 = v.oooo.copy() * -0.5 tmp12 += tmp10.transpose((3, 2, 1, 0)) * -0.25 tmp12 += einsum(t1, (0, 1), tmp11, (2, 3, 4, 1), (3, 2, 0, 4)) * -1 - tmp8 = f.ov.copy() - tmp8 += tmp7 - l1new += einsum(tmp21, (0, 1), tmp8, (1, 2), (2, 0)) * -0.5 - tmp15 = tmp1.transpose((1, 0, 3, 2)).copy() * -0.5 - tmp15 += tmp2.transpose((0, 1, 3, 2)) - tmp59 = tmp1.transpose((1, 0, 3, 2)).copy() * -1 - del tmp1 - tmp59 += tmp2.transpose((0, 1, 3, 2)) * 2 - del tmp2 - l2new += einsum(tmp59, (0, 1, 2, 3), v.oovv, (2, 3, 4, 5), (4, 5, 1, 0)) * 0.25 - del tmp59 - tmp45 = tmp41.transpose((0, 1, 3, 2)).copy() - del tmp41 - tmp45 += tmp42.transpose((0, 1, 3, 2)) * -1 - del tmp42 - tmp45 += tmp44.transpose((1, 0, 3, 2)) + tmp38 = tmp32.copy() * -1 + del tmp32 + tmp38 += tmp33 * 0.5 + del tmp33 + tmp38 += tmp36.transpose((1, 0, 3, 2)) + del tmp36 + tmp38 += tmp37.transpose((1, 0, 3, 2)) + del tmp37 + tmp49 = tmp44.transpose((0, 1, 3, 2)).copy() del tmp44 - l2new += tmp45.transpose((3, 2, 1, 0)) * -1 - l2new += tmp45.transpose((3, 2, 0, 1)) - del tmp45 - tmp57 = einsum(l2, (0, 1, 2, 3), tmp56, (3, 4), (2, 4, 0, 1)) - del tmp56 - l2new += tmp57.transpose((2, 3, 1, 0)) - l2new += tmp57.transpose((2, 3, 0, 1)) * -1 - del tmp57 - tmp48 = tmp46.transpose((0, 1, 3, 2)).copy() * -1 + tmp49 += tmp46.transpose((0, 1, 3, 2)) * -1 del tmp46 - tmp48 += tmp47.transpose((0, 1, 3, 2)) - del tmp47 - l2new += tmp48.transpose((2, 3, 1, 0)) * -1 - l2new += tmp48.transpose((2, 3, 0, 1)) + tmp49 += tmp48.transpose((1, 0, 3, 2)) del tmp48 + tmp42 = tmp40.copy() + del tmp40 + tmp42 += tmp41 * -1 + del tmp41 + tmp31 = einsum(tmp7, (0, 1), l1, (2, 3), (3, 0, 2, 1)) + del tmp7 + tmp31 += tmp28 + del tmp28 + tmp31 += tmp30.transpose((1, 0, 3, 2)) + del tmp30 + tmp54 = tmp52.transpose((1, 0, 2, 3)).copy() * -1 + del tmp52 + tmp54 += tmp53 + del tmp53 + tmp51 = einsum(tmp50, (0, 1), l2, (2, 3, 4, 0), (4, 1, 2, 3)) + del tmp50 + tmp57 = tmp55.transpose((0, 1, 3, 2)).copy() * -1 + del tmp55 + tmp57 += tmp56.transpose((0, 1, 3, 2)) + del tmp56 tmp58 = v.oooo.copy() tmp58 += tmp10.transpose((1, 0, 3, 2)) * 0.5 del tmp10 - tmp58 += einsum(t1, (0, 1), tmp11, (2, 3, 4, 1), (4, 0, 3, 2)) * -2 + tmp58 += einsum(tmp11, (0, 1, 2, 3), t1, (4, 3), (2, 4, 1, 0)) * -2 del tmp11 - l2new += einsum(tmp58, (0, 1, 2, 3), l2, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 - del tmp58 - tmp32 = einsum(l1, (0, 1), tmp7, (2, 3), (1, 2, 0, 3)) - del tmp7 - tmp32 += tmp29 - del tmp29 - tmp32 += tmp31.transpose((1, 0, 3, 2)) - del tmp31 - l2new += tmp32.transpose((3, 2, 1, 0)) - l2new += tmp32.transpose((2, 3, 1, 0)) * -1 - l2new += tmp32.transpose((3, 2, 0, 1)) * -1 - l2new += tmp32.transpose((2, 3, 0, 1)) - del tmp32 - tmp55 = tmp53.copy() - del tmp53 - tmp55 += tmp54 * -1 - del tmp54 - l2new += tmp55.transpose((3, 2, 1, 0)) - l2new += tmp55.transpose((2, 3, 1, 0)) * -1 - l2new += tmp55.transpose((3, 2, 0, 1)) * -1 - l2new += tmp55.transpose((2, 3, 0, 1)) - del tmp55 - tmp51 = tmp49.transpose((1, 0, 2, 3)).copy() * -1 - del tmp49 - tmp51 += tmp50 - del tmp50 - l2new += tmp51.transpose((3, 2, 0, 1)) - l2new += tmp51.transpose((2, 3, 0, 1)) * -1 - del tmp51 - tmp39 = tmp33.copy() * -1 - del tmp33 - tmp39 += tmp34 * 0.5 - del tmp34 - tmp39 += tmp37.transpose((1, 0, 3, 2)) - del tmp37 - tmp39 += tmp38.transpose((1, 0, 3, 2)) - del tmp38 - l2new += tmp39.transpose((3, 2, 0, 1)) - l2new += tmp39.transpose((2, 3, 0, 1)) * -1 - del tmp39 - tmp25 = f.vv.copy() - tmp25 += tmp24 * -1 - del tmp24 - l1new += einsum(tmp25, (0, 1), l1, (0, 2), (1, 2)) + tmp59 = tmp3.transpose((1, 0, 3, 2)).copy() * -1 + tmp59 += tmp4.transpose((0, 1, 3, 2)) * 2 + tmp24 = f.vv.copy() + tmp24 += tmp23 * -1 + del tmp23 + tmp27 = f.oo.copy() + tmp27 += tmp25.transpose((1, 0)) del tmp25 - tmp22 = t1.copy() * -1 - tmp22 += einsum(l1, (0, 1), t2, (2, 1, 3, 0), (2, 3)) * -1 - tmp22 += einsum(tmp0, (0, 1, 2, 3), t2, (1, 0, 4, 3), (2, 4)) * 0.5 - tmp22 += einsum(t1, (0, 1), tmp21, (0, 2), (2, 1)) * 0.5 - del tmp21 - l1new += einsum(v.oovv, (0, 1, 2, 3), tmp22, (1, 3), (2, 0)) * -1 - del tmp22 - tmp13 = v.ovoo.transpose((0, 2, 3, 1)).copy() * -0.5 - tmp13 += einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (0, 4, 5, 1)) * -0.25 - tmp13 += einsum(tmp6, (0, 1, 2, 3), t2, (4, 1, 5, 3), (2, 4, 0, 5)) - del tmp6 - tmp13 += einsum(tmp8, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) * 0.5 - tmp13 += einsum(tmp9, (0, 1, 2, 3), t1, (4, 2), (1, 0, 4, 3)) * -1 - del tmp9 - tmp13 += einsum(tmp12, (0, 1, 2, 3), t1, (0, 4), (1, 3, 2, 4)) * -1 - del tmp12 - l1new += einsum(l2, (0, 1, 2, 3), tmp13, (4, 2, 3, 1), (0, 4)) - del tmp13 - tmp14 = v.ovvv.copy() - tmp14 += einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 1), (4, 0, 2, 3)) * -1 - l1new += einsum(l2, (0, 1, 2, 3), tmp14, (3, 4, 0, 1), (4, 2)) * -0.5 - del tmp14 - tmp3 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 5, 1), (2, 4, 0, 5)) - l1new += einsum(tmp3, (0, 1, 2, 3), v.ovvv, (1, 2, 4, 3), (4, 0)) * -1 - del tmp3 - tmp28 = f.oo.copy() * 2 - tmp28 += tmp26.transpose((1, 0)) * 2 + tmp27 += tmp26 * 0.5 del tmp26 - tmp28 += tmp27 - del tmp27 - tmp28 += einsum(t1, (0, 1), tmp8, (2, 1), (0, 2)) * 2 - del tmp8 - l1new += einsum(tmp28, (0, 1), l1, (2, 0), (2, 1)) * -0.5 - del tmp28 - tmp18 = einsum(l1, (0, 1), t1, (1, 2), (0, 2)) * 2 - tmp18 += tmp17 + tmp27 += einsum(t1, (0, 1), tmp8, (2, 1), (0, 2)) + tmp18 = einsum(t1, (0, 1), l1, (2, 0), (2, 1)) + tmp18 += tmp17 * 0.5 del tmp17 - l1new += einsum(tmp18, (0, 1), v.ovvv, (2, 0, 3, 1), (3, 2)) * 0.5 - del tmp18 + tmp0 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 5, 1), (2, 4, 0, 5)) + tmp22 = t1.copy() * -2 + tmp22 += einsum(l1, (0, 1), t2, (2, 1, 3, 0), (2, 3)) * -2 + tmp22 += einsum(t2, (0, 1, 2, 3), tmp2, (1, 0, 4, 3), (4, 2)) + tmp22 += einsum(t1, (0, 1), tmp21, (0, 2), (2, 1)) + tmp14 = v.ovvv.copy() + tmp14 += einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 1), (4, 0, 2, 3)) * -1 tmp16 = einsum(t2, (0, 1, 2, 3), l1, (3, 4), (4, 0, 1, 2)) - tmp16 += einsum(tmp0, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) * -2 - del tmp0 + tmp16 += einsum(t2, (0, 1, 2, 3), tmp2, (4, 1, 5, 3), (4, 0, 5, 2)) * -2 tmp16 += einsum(tmp15, (0, 1, 2, 3), t1, (0, 4), (1, 3, 2, 4)) * -1 del tmp15 - l1new += einsum(tmp16, (0, 1, 2, 3), v.oovv, (1, 2, 4, 3), (4, 0)) * 0.5 - del tmp16 - l1new += f.ov.transpose((1, 0)) - l1new += einsum(v.ovov, (0, 1, 2, 3), l1, (1, 2), (3, 0)) * -1 - l2new += einsum(l2, (0, 1, 2, 3), v.vvvv, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + tmp13 = v.ovoo.transpose((0, 2, 3, 1)).copy() * -1 + tmp13 += einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (0, 4, 5, 1)) * -0.5 + tmp13 += einsum(t2, (0, 1, 2, 3), tmp6, (4, 1, 5, 3), (5, 0, 4, 2)) * 2 + del tmp6 + tmp13 += einsum(tmp8, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp13 += einsum(tmp9, (0, 1, 2, 3), t1, (4, 2), (1, 0, 4, 3)) * -2 + del tmp9 + tmp13 += einsum(t1, (0, 1), tmp12, (0, 2, 3, 4), (2, 4, 3, 1)) * -2 + del tmp12 + l2new = einsum(v.ovvv, (0, 1, 2, 3), tmp2, (4, 5, 0, 1), (2, 3, 4, 5)) l2new += v.oovv.transpose((2, 3, 0, 1)) - l2new += einsum(f.ov, (0, 1), l1, (2, 3), (1, 2, 0, 3)) - l2new += einsum(f.ov, (0, 1), l1, (2, 3), (2, 1, 0, 3)) * -1 + l2new += einsum(l2, (0, 1, 2, 3), v.vvvv, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + l2new += tmp31.transpose((2, 3, 0, 1)) + l2new += tmp31.transpose((3, 2, 0, 1)) * -1 + l2new += tmp31.transpose((2, 3, 1, 0)) * -1 + l2new += tmp31.transpose((3, 2, 1, 0)) + del tmp31 + l2new += tmp38.transpose((2, 3, 0, 1)) * -1 + l2new += tmp38.transpose((3, 2, 0, 1)) + del tmp38 + l2new += tmp42.transpose((2, 3, 0, 1)) + l2new += tmp42.transpose((3, 2, 0, 1)) * -1 + l2new += tmp42.transpose((2, 3, 1, 0)) * -1 + l2new += tmp42.transpose((3, 2, 1, 0)) + del tmp42 + l2new += tmp49.transpose((3, 2, 0, 1)) + l2new += tmp49.transpose((3, 2, 1, 0)) * -1 + del tmp49 + l2new += tmp51.transpose((2, 3, 0, 1)) * -1 + l2new += tmp51.transpose((2, 3, 1, 0)) + del tmp51 + l2new += tmp54.transpose((2, 3, 0, 1)) * -1 + l2new += tmp54.transpose((3, 2, 0, 1)) + del tmp54 + l2new += einsum(l1, (0, 1), f.ov, (2, 3), (3, 0, 2, 1)) + l2new += einsum(l1, (0, 1), f.ov, (2, 3), (0, 3, 2, 1)) * -1 l2new += einsum(f.ov, (0, 1), l1, (2, 3), (1, 2, 3, 0)) * -1 l2new += einsum(l1, (0, 1), f.ov, (2, 3), (0, 3, 1, 2)) + l2new += tmp57.transpose((2, 3, 0, 1)) + l2new += tmp57.transpose((2, 3, 1, 0)) * -1 + del tmp57 + l2new += einsum(tmp58, (0, 1, 2, 3), l2, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + del tmp58 + l2new += einsum(tmp59, (0, 1, 2, 3), v.oovv, (2, 3, 4, 5), (4, 5, 1, 0)) * 0.25 + del tmp59 + l1new = einsum(v.ovvv, (0, 1, 2, 3), tmp0, (4, 0, 1, 3), (2, 4)) * -1 + del tmp0 + l1new += einsum(tmp1, (0, 1, 2, 3), tmp2, (4, 0, 1, 2), (3, 4)) + del tmp1 + l1new += einsum(tmp2, (0, 1, 2, 3), v.ovov, (2, 3, 1, 4), (4, 0)) * -1 + del tmp2 + l1new += einsum(l1, (0, 1), v.ovov, (2, 0, 1, 3), (3, 2)) * -1 + l1new += einsum(tmp3, (0, 1, 2, 3), v.ovoo, (1, 4, 3, 2), (4, 0)) * 0.25 + del tmp3 + l1new += einsum(tmp4, (0, 1, 2, 3), v.ooov, (2, 3, 1, 4), (4, 0)) * -0.5 + del tmp4 + l1new += f.ov.transpose((1, 0)) + l1new += einsum(l2, (0, 1, 2, 3), tmp13, (4, 2, 3, 1), (0, 4)) * 0.5 + del tmp13 + l1new += einsum(l2, (0, 1, 2, 3), tmp14, (3, 4, 0, 1), (4, 2)) * -0.5 + del tmp14 + l1new += einsum(v.oovv, (0, 1, 2, 3), tmp16, (4, 0, 1, 3), (2, 4)) * 0.5 + del tmp16 + l1new += einsum(tmp18, (0, 1), v.ovvv, (2, 0, 3, 1), (3, 2)) + del tmp18 + l1new += einsum(tmp22, (0, 1), v.oovv, (2, 0, 3, 1), (3, 2)) * -0.5 + del tmp22 + l1new += einsum(tmp21, (0, 1), v.ooov, (2, 1, 0, 3), (3, 2)) * 0.5 + l1new += einsum(l1, (0, 1), tmp24, (0, 2), (2, 1)) + del tmp24 + l1new += einsum(l1, (0, 1), tmp27, (1, 2), (0, 2)) * -1 + del tmp27 + l1new += einsum(tmp21, (0, 1), tmp8, (1, 2), (2, 0)) * -0.5 + del tmp8, tmp21 return {f"l1new": l1new, f"l2new": l2new} def make_rdm1_f(l1=None, l2=None, t1=None, t2=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:41.893894. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:16.273707. Parameters ---------- @@ -486,33 +484,33 @@ def make_rdm1_f(l1=None, l2=None, t1=None, t2=None, **kwargs): oo=np.eye(t2.shape[0]), vv=np.eye(t2.shape[-1]), ) - tmp1 = einsum(t2, (0, 1, 2, 3), l2, (2, 3, 4, 1), (4, 0)) - rdm1.oo = tmp1.transpose((1, 0)).copy() * -0.5 - tmp0 = einsum(l1, (0, 1), t1, (2, 0), (1, 2)) - rdm1.oo += tmp0.transpose((1, 0)) * -1 - tmp3 = tmp0.copy() * 2 - del tmp0 - tmp3 += tmp1 - del tmp1 - rdm1.ov = einsum(t1, (0, 1), tmp3, (0, 2), (2, 1)) * -0.5 - del tmp3 + tmp1 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 0, 1), (2, 4)) + tmp0 = einsum(t1, (0, 1), l1, (1, 2), (2, 0)) tmp2 = einsum(l2, (0, 1, 2, 3), t1, (4, 1), (2, 3, 4, 0)) + tmp3 = tmp0.copy() + tmp3 += tmp1 * 0.5 + rdm1.vv = einsum(t1, (0, 1), l1, (2, 0), (2, 1)) + rdm1.vv += einsum(t2, (0, 1, 2, 3), l2, (4, 3, 0, 1), (4, 2)) * 0.5 + rdm1.vo = l1.copy() + rdm1.ov = t1.copy() rdm1.ov += einsum(t2, (0, 1, 2, 3), tmp2, (1, 0, 4, 3), (4, 2)) * -0.5 del tmp2 - rdm1.oo += delta.oo - del delta rdm1.ov += einsum(l1, (0, 1), t2, (2, 1, 3, 0), (2, 3)) - rdm1.ov += t1 - rdm1.vo = l1.copy() - rdm1.vv = einsum(l1, (0, 1), t1, (1, 2), (0, 2)) - rdm1.vv += einsum(l2, (0, 1, 2, 3), t2, (2, 3, 4, 1), (0, 4)) * 0.5 + rdm1.ov += einsum(tmp3, (0, 1), t1, (0, 2), (1, 2)) * -1 + del tmp3 + rdm1.oo = delta.oo.copy() + del delta + rdm1.oo += tmp0.transpose((1, 0)) * -1 + del tmp0 + rdm1.oo += tmp1.transpose((1, 0)) * -0.5 + del tmp1 rdm1 = np.block([[rdm1.oo, rdm1.ov], [rdm1.vo, rdm1.vv]]) return rdm1 def make_rdm2_f(l1=None, l2=None, t1=None, t2=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:48.706124. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:22.235969. Parameters ---------- @@ -536,197 +534,196 @@ def make_rdm2_f(l1=None, l2=None, t1=None, t2=None, **kwargs): oo=np.eye(t2.shape[0]), vv=np.eye(t2.shape[-1]), ) + tmp4 = einsum(t1, (0, 1), l1, (1, 2), (2, 0)) tmp1 = einsum(l2, (0, 1, 2, 3), t1, (4, 1), (2, 3, 4, 0)) - rdm2.vooo = tmp1.transpose((3, 2, 1, 0)).copy() - rdm2.ovoo = tmp1.transpose((2, 3, 1, 0)).copy() * -1 - tmp3 = einsum(l1, (0, 1), t1, (2, 0), (1, 2)) - rdm2.oovo = einsum(tmp3, (0, 1), t1, (2, 3), (1, 2, 3, 0)) - rdm2.oovo += einsum(tmp3, (0, 1), t1, (2, 3), (2, 1, 3, 0)) * -1 - rdm2.ooov = einsum(tmp3, (0, 1), t1, (2, 3), (1, 2, 0, 3)) * -1 - rdm2.ooov += einsum(tmp3, (0, 1), t1, (2, 3), (2, 1, 0, 3)) - rdm2.oooo = einsum(tmp3, (0, 1), delta.oo, (2, 3), (2, 1, 3, 0)) * -1 - rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (1, 2, 3, 0)) - rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (2, 1, 0, 3)) - rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (1, 2, 0, 3)) * -1 - tmp4 = einsum(t2, (0, 1, 2, 3), l2, (2, 3, 4, 1), (4, 0)) - rdm2.oovo += einsum(tmp4, (0, 1), t1, (2, 3), (1, 2, 3, 0)) * 0.5 - rdm2.oovo += einsum(tmp4, (0, 1), t1, (2, 3), (2, 1, 3, 0)) * -0.5 - rdm2.ooov += einsum(tmp4, (0, 1), t1, (2, 3), (1, 2, 0, 3)) * -0.5 - rdm2.ooov += einsum(tmp4, (0, 1), t1, (2, 3), (2, 1, 0, 3)) * 0.5 - rdm2.oooo += einsum(delta.oo, (0, 1), tmp4, (2, 3), (0, 3, 1, 2)) * -0.5 - rdm2.oooo += einsum(delta.oo, (0, 1), tmp4, (2, 3), (3, 0, 1, 2)) * 0.5 - rdm2.oooo += einsum(tmp4, (0, 1), delta.oo, (2, 3), (2, 1, 0, 3)) * 0.5 - rdm2.oooo += einsum(tmp4, (0, 1), delta.oo, (2, 3), (1, 2, 0, 3)) * -0.5 + tmp3 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 0, 1), (2, 4)) tmp21 = einsum(l2, (0, 1, 2, 3), t2, (4, 3, 5, 1), (2, 4, 0, 5)) - rdm2.vovo = tmp21.transpose((2, 1, 3, 0)).copy() * -1 - rdm2.voov = tmp21.transpose((2, 1, 0, 3)).copy() - rdm2.ovvo = tmp21.transpose((1, 2, 3, 0)).copy() - rdm2.ovov = tmp21.transpose((1, 2, 0, 3)).copy() * -1 - tmp12 = einsum(t2, (0, 1, 2, 3), tmp1, (4, 1, 5, 3), (4, 5, 0, 2)) * -1 - rdm2.oovo += tmp12.transpose((2, 1, 3, 0)) * -1 - rdm2.oovo += tmp12.transpose((1, 2, 3, 0)) - rdm2.ooov += tmp12.transpose((2, 1, 0, 3)) - rdm2.ooov += tmp12.transpose((1, 2, 0, 3)) * -1 - tmp7 = einsum(t1, (0, 1), tmp3, (0, 2), (2, 1)) - tmp6 = einsum(l1, (0, 1), t2, (2, 1, 3, 0), (2, 3)) - tmp2 = einsum(t1, (0, 1), tmp1, (2, 3, 4, 1), (2, 3, 0, 4)) - rdm2.oooo += tmp2.transpose((2, 3, 1, 0)) * -1 - tmp0 = einsum(t2, (0, 1, 2, 3), l2, (2, 3, 4, 5), (4, 5, 0, 1)) - rdm2.oooo += tmp0.transpose((3, 2, 1, 0)) * 0.5 + tmp7 = einsum(l1, (0, 1), t2, (2, 1, 3, 0), (2, 3)) + tmp8 = einsum(t1, (0, 1), tmp4, (0, 2), (2, 1)) + tmp6 = einsum(t2, (0, 1, 2, 3), tmp1, (4, 1, 5, 3), (4, 5, 0, 2)) * -1 tmp5 = einsum(t2, (0, 1, 2, 3), l1, (3, 4), (4, 0, 1, 2)) - rdm2.oovo += tmp5.transpose((2, 1, 3, 0)) - rdm2.ooov += tmp5.transpose((2, 1, 0, 3)) * -1 - tmp14 = tmp3.copy() * 2 - tmp14 += tmp4 - tmp29 = einsum(t1, (0, 1), tmp1, (2, 0, 3, 4), (2, 3, 4, 1)) - rdm2.vovo += tmp29.transpose((2, 1, 3, 0)) - rdm2.voov += tmp29.transpose((2, 1, 0, 3)) * -1 - rdm2.ovvo += tmp29.transpose((1, 2, 3, 0)) * -1 - rdm2.ovov += tmp29.transpose((1, 2, 0, 3)) - tmp30 = einsum(l1, (0, 1), t1, (1, 2), (0, 2)) - rdm2.ovvv = einsum(t1, (0, 1), tmp30, (2, 3), (0, 2, 3, 1)) * -1 - rdm2.ovvv += einsum(tmp30, (0, 1), t1, (2, 3), (2, 0, 3, 1)) - tmp25 = einsum(l2, (0, 1, 2, 3), t2, (2, 3, 4, 1), (0, 4)) - tmp36 = einsum(tmp21, (0, 1, 2, 3), t1, (0, 4), (1, 2, 4, 3)) - rdm2.vovv = tmp36.transpose((1, 0, 3, 2)).copy() * -1 - rdm2.vovv += tmp36.transpose((1, 0, 2, 3)) - tmp18 = einsum(t1, (0, 1), tmp12, (0, 2, 3, 4), (2, 3, 1, 4)) - del tmp12 - tmp8 = tmp6.copy() - tmp8 += tmp7 * -1 - del tmp7 - rdm2.ooov += einsum(delta.oo, (0, 1), tmp8, (2, 3), (0, 2, 1, 3)) - rdm2.ooov += einsum(tmp8, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -1 + tmp2 = einsum(t1, (0, 1), tmp1, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp0 = einsum(l2, (0, 1, 2, 3), t2, (4, 5, 0, 1), (2, 3, 4, 5)) + tmp14 = tmp4.copy() * 2 + tmp14 += tmp3 + tmp25 = einsum(t2, (0, 1, 2, 3), l2, (4, 3, 0, 1), (4, 2)) + tmp30 = einsum(t1, (0, 1), l1, (2, 0), (2, 1)) + tmp29 = einsum(tmp1, (0, 1, 2, 3), t1, (1, 4), (0, 2, 3, 4)) + tmp36 = einsum(t1, (0, 1), tmp21, (0, 2, 3, 4), (2, 3, 1, 4)) + tmp9 = tmp7.copy() + tmp9 += tmp8 * -1 + del tmp8 + tmp18 = einsum(t1, (0, 1), tmp6, (0, 2, 3, 4), (2, 3, 1, 4)) + tmp20 = einsum(t1, (0, 1), tmp5, (0, 2, 3, 4), (2, 3, 1, 4)) + tmp22 = einsum(t2, (0, 1, 2, 3), tmp21, (1, 4, 3, 5), (0, 4, 2, 5)) tmp13 = tmp0.transpose((1, 0, 3, 2)).copy() * -0.5 tmp13 += tmp2.transpose((0, 1, 3, 2)) - rdm2.oovv = einsum(t2, (0, 1, 2, 3), tmp13, (0, 1, 4, 5), (5, 4, 2, 3)) * 0.5 - rdm2.ooov += einsum(tmp13, (0, 1, 2, 3), t1, (0, 4), (3, 2, 1, 4)) * -1 - tmp10 = einsum(tmp4, (0, 1), t1, (0, 2), (1, 2)) - tmp9 = einsum(t2, (0, 1, 2, 3), tmp1, (1, 0, 4, 3), (4, 2)) - tmp20 = einsum(t1, (0, 1), tmp5, (0, 2, 3, 4), (2, 3, 1, 4)) - del tmp5 - tmp22 = einsum(t2, (0, 1, 2, 3), tmp21, (1, 4, 3, 5), (4, 0, 5, 2)) - del tmp21 - tmp15 = einsum(t1, (0, 1), tmp14, (0, 2), (2, 1)) * 0.5 + tmp10 = einsum(t2, (0, 1, 2, 3), tmp1, (1, 0, 4, 3), (4, 2)) + tmp11 = einsum(tmp3, (0, 1), t1, (0, 2), (1, 2)) + tmp15 = einsum(tmp14, (0, 1), t1, (0, 2), (1, 2)) * 0.5 del tmp14 tmp38 = einsum(l2, (0, 1, 2, 3), t1, (3, 4), (2, 0, 1, 4)) - rdm2.vvvv = einsum(tmp38, (0, 1, 2, 3), t1, (0, 4), (1, 2, 4, 3)) - rdm2.vvvo = tmp38.transpose((2, 1, 3, 0)).copy() - rdm2.vvov = tmp38.transpose((2, 1, 0, 3)).copy() * -1 - del tmp38 - tmp34 = einsum(tmp29, (0, 1, 2, 3), t1, (0, 4), (1, 2, 3, 4)) * -1 - del tmp29 - rdm2.vovv += tmp34.transpose((1, 0, 3, 2)) - rdm2.ovvv += tmp34.transpose((0, 1, 3, 2)) * -1 - del tmp34 - tmp33 = einsum(tmp1, (0, 1, 2, 3), t2, (1, 0, 4, 5), (2, 3, 4, 5)) * -1 - del tmp1 - rdm2.vovv += tmp33.transpose((1, 0, 3, 2)) * 0.5 - rdm2.ovvv += tmp33.transpose((0, 1, 3, 2)) * -0.5 - del tmp33 - tmp35 = einsum(t2, (0, 1, 2, 3), l1, (4, 1), (0, 4, 2, 3)) - rdm2.vovv += tmp35.transpose((1, 0, 3, 2)) - rdm2.ovvv += tmp35.transpose((0, 1, 3, 2)) * -1 - del tmp35 - tmp31 = tmp30.copy() - tmp31 += tmp25 * 0.5 - rdm2.vovv += einsum(tmp31, (0, 1), t1, (2, 3), (0, 2, 1, 3)) - rdm2.vovv += einsum(tmp31, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * -1 - rdm2.voov += einsum(tmp31, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -1 - rdm2.ovov += einsum(tmp31, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) - del tmp31 + tmp32 = tmp30.copy() + tmp32 += tmp25 * 0.5 + tmp34 = einsum(tmp1, (0, 1, 2, 3), t2, (1, 0, 4, 5), (2, 3, 4, 5)) * -1 + tmp35 = einsum(tmp29, (0, 1, 2, 3), t1, (0, 4), (1, 2, 3, 4)) * -1 + tmp33 = einsum(l1, (0, 1), t2, (2, 1, 3, 4), (2, 0, 3, 4)) tmp37 = tmp36.copy() - del tmp36 tmp37 += einsum(tmp25, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * -0.5 - rdm2.ovvv += tmp37.transpose((0, 1, 3, 2)) - rdm2.ovvv += tmp37 * -1 - del tmp37 - tmp32 = tmp30.copy() * 2 - del tmp30 - tmp32 += tmp25 - rdm2.vovo += einsum(tmp32, (0, 1), delta.oo, (2, 3), (0, 2, 1, 3)) * 0.5 - rdm2.ovvo += einsum(tmp32, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) * -0.5 - del tmp32 - tmp27 = einsum(tmp4, (0, 1), t2, (2, 0, 3, 4), (2, 1, 3, 4)) - del tmp4 - rdm2.oovv += tmp27.transpose((1, 0, 3, 2)) * -0.5 - rdm2.oovv += tmp27.transpose((0, 1, 3, 2)) * 0.5 - del tmp27 - tmp26 = einsum(tmp25, (0, 1), t2, (2, 3, 4, 0), (2, 3, 4, 1)) - del tmp25 - rdm2.oovv += tmp26.transpose((0, 1, 3, 2)) * 0.5 - rdm2.oovv += tmp26 * -0.5 - del tmp26 - tmp24 = einsum(t2, (0, 1, 2, 3), tmp3, (1, 4), (4, 0, 2, 3)) - del tmp3 - rdm2.oovv += tmp24.transpose((1, 0, 3, 2)) - rdm2.oovv += tmp24.transpose((0, 1, 3, 2)) * -1 - del tmp24 + tmp31 = tmp30.copy() * 2 + tmp31 += tmp25 + tmp27 = einsum(t2, (0, 1, 2, 3), tmp3, (1, 4), (0, 4, 2, 3)) + tmp24 = einsum(t2, (0, 1, 2, 3), tmp4, (1, 4), (4, 0, 2, 3)) tmp19 = tmp18.copy() del tmp18 - tmp19 += einsum(tmp8, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * -1 - del tmp8 - rdm2.oovv += tmp19.transpose((1, 0, 3, 2)) * -1 - rdm2.oovv += tmp19.transpose((1, 0, 2, 3)) - rdm2.oovv += tmp19.transpose((0, 1, 3, 2)) - rdm2.oovv += tmp19 * -1 - del tmp19 - tmp28 = einsum(tmp13, (0, 1, 2, 3), t1, (0, 4), (1, 3, 2, 4)) * -2 - del tmp13 - rdm2.oovv += einsum(t1, (0, 1), tmp28, (0, 2, 3, 4), (2, 3, 1, 4)) * 0.5 - del tmp28 - tmp11 = tmp9.copy() - tmp11 += tmp10 - del tmp10 - rdm2.oovv += einsum(tmp11, (0, 1), t1, (2, 3), (0, 2, 1, 3)) * -0.5 - rdm2.oovv += einsum(tmp11, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * 0.5 - rdm2.oovv += einsum(t1, (0, 1), tmp11, (2, 3), (0, 2, 3, 1)) * 0.5 - rdm2.oovv += einsum(tmp11, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * -0.5 - rdm2.ooov += einsum(delta.oo, (0, 1), tmp11, (2, 3), (0, 2, 1, 3)) * -0.5 - rdm2.ooov += einsum(tmp11, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * 0.5 - del tmp11 + tmp19 += einsum(t1, (0, 1), tmp9, (2, 3), (0, 2, 1, 3)) * -1 tmp23 = tmp20.copy() del tmp20 tmp23 += tmp22 del tmp22 - rdm2.oovv += tmp23.transpose((0, 1, 3, 2)) * -1 - rdm2.oovv += tmp23 - del tmp23 + tmp28 = einsum(t1, (0, 1), tmp13, (0, 2, 3, 4), (2, 4, 3, 1)) * -2 + tmp26 = einsum(tmp25, (0, 1), t2, (2, 3, 4, 0), (2, 3, 4, 1)) + del tmp25 + tmp12 = tmp10.copy() + tmp12 += tmp11 + del tmp11 tmp17 = tmp0.transpose((1, 0, 3, 2)).copy() * -1 - del tmp0 tmp17 += tmp2.transpose((0, 1, 3, 2)) * 2 - del tmp2 - rdm2.oovo += einsum(tmp17, (0, 1, 2, 3), t1, (0, 4), (3, 2, 4, 1)) * 0.5 - del tmp17 - tmp16 = tmp6.copy() * -1 - del tmp6 - tmp16 += tmp9 * 0.5 - del tmp9 + tmp16 = tmp7.copy() * -1 + del tmp7 + tmp16 += tmp10 * 0.5 + del tmp10 tmp16 += tmp15 del tmp15 - rdm2.oovo += einsum(delta.oo, (0, 1), tmp16, (2, 3), (0, 2, 3, 1)) - rdm2.oovo += einsum(tmp16, (0, 1), delta.oo, (2, 3), (0, 2, 1, 3)) * -1 - del tmp16 - rdm2.oooo += einsum(delta.oo, (0, 1), delta.oo, (2, 3), (0, 2, 1, 3)) - rdm2.oooo += einsum(delta.oo, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) * -1 - rdm2.ooov += einsum(delta.oo, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 - rdm2.ooov += einsum(t1, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) - rdm2.oovo += einsum(delta.oo, (0, 1), t1, (2, 3), (2, 0, 3, 1)) - rdm2.oovo += einsum(t1, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) * -1 - rdm2.ovoo += einsum(delta.oo, (0, 1), l1, (2, 3), (0, 2, 3, 1)) * -1 - rdm2.ovoo += einsum(l1, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) + rdm2.vvvv = einsum(t2, (0, 1, 2, 3), l2, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + rdm2.vvvv += einsum(tmp38, (0, 1, 2, 3), t1, (0, 4), (1, 2, 4, 3)) + rdm2.vvvo = tmp38.transpose((2, 1, 3, 0)).copy() + rdm2.vvov = tmp38.transpose((2, 1, 0, 3)).copy() * -1 + del tmp38 + rdm2.vovv = tmp33.transpose((1, 0, 3, 2)).copy() + rdm2.vovv += tmp34.transpose((1, 0, 3, 2)) * 0.5 + rdm2.vovv += tmp35.transpose((1, 0, 3, 2)) + rdm2.vovv += einsum(tmp32, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.vovv += einsum(t1, (0, 1), tmp32, (2, 3), (2, 0, 3, 1)) + rdm2.vovv += tmp36.transpose((1, 0, 2, 3)) + rdm2.vovv += tmp36.transpose((1, 0, 3, 2)) * -1 + del tmp36 + rdm2.ovvv = tmp33.transpose((0, 1, 3, 2)).copy() * -1 + del tmp33 + rdm2.ovvv += tmp34.transpose((0, 1, 3, 2)) * -0.5 + del tmp34 + rdm2.ovvv += tmp35.transpose((0, 1, 3, 2)) * -1 + del tmp35 + rdm2.ovvv += einsum(tmp30, (0, 1), t1, (2, 3), (2, 0, 3, 1)) + rdm2.ovvv += einsum(t1, (0, 1), tmp30, (2, 3), (0, 2, 3, 1)) * -1 + del tmp30 + rdm2.ovvv += tmp37 * -1 + rdm2.ovvv += tmp37.transpose((0, 1, 3, 2)) + del tmp37 + rdm2.vvoo = l2.copy() + rdm2.vovo = tmp21.transpose((2, 1, 3, 0)).copy() * -1 + rdm2.vovo += tmp29.transpose((2, 1, 3, 0)) + rdm2.vovo += einsum(l1, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.vovo += einsum(tmp32, (0, 1), delta.oo, (2, 3), (0, 2, 1, 3)) + rdm2.voov = tmp21.transpose((2, 1, 0, 3)).copy() + rdm2.voov += tmp29.transpose((2, 1, 0, 3)) * -1 + rdm2.voov += einsum(l1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) + rdm2.voov += einsum(tmp31, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -0.5 + rdm2.ovvo = tmp21.transpose((1, 2, 3, 0)).copy() + rdm2.ovvo += tmp29.transpose((1, 2, 3, 0)) * -1 + rdm2.ovvo += einsum(l1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) + rdm2.ovvo += einsum(tmp32, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) * -1 + del tmp32 + rdm2.ovov = tmp21.transpose((1, 2, 0, 3)).copy() * -1 + del tmp21 + rdm2.ovov += tmp29.transpose((1, 2, 0, 3)) + del tmp29 + rdm2.ovov += einsum(l1, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 + rdm2.ovov += einsum(tmp31, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) * 0.5 + del tmp31 + rdm2.oovv = t2.copy() + rdm2.oovv += tmp19 * -1 + rdm2.oovv += tmp19.transpose((0, 1, 3, 2)) + rdm2.oovv += tmp19.transpose((1, 0, 2, 3)) + rdm2.oovv += tmp19.transpose((1, 0, 3, 2)) * -1 + del tmp19 + rdm2.oovv += tmp23 + rdm2.oovv += tmp23.transpose((0, 1, 3, 2)) * -1 + del tmp23 + rdm2.oovv += tmp24.transpose((0, 1, 3, 2)) * -1 + rdm2.oovv += tmp24.transpose((1, 0, 3, 2)) + del tmp24 + rdm2.oovv += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 + rdm2.oovv += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) + rdm2.oovv += tmp26 * -0.5 + rdm2.oovv += tmp26.transpose((0, 1, 3, 2)) * 0.5 + del tmp26 + rdm2.oovv += tmp27.transpose((0, 1, 3, 2)) * 0.5 + rdm2.oovv += tmp27.transpose((1, 0, 3, 2)) * -0.5 + del tmp27 + rdm2.oovv += einsum(t1, (0, 1), tmp12, (2, 3), (0, 2, 1, 3)) * -0.5 + rdm2.oovv += einsum(tmp12, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * 0.5 + rdm2.oovv += einsum(tmp12, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * 0.5 + rdm2.oovv += einsum(t1, (0, 1), tmp12, (2, 3), (2, 0, 3, 1)) * -0.5 + rdm2.oovv += einsum(tmp13, (0, 1, 2, 3), t2, (0, 1, 4, 5), (3, 2, 4, 5)) * 0.5 + rdm2.oovv += einsum(t1, (0, 1), tmp28, (0, 2, 3, 4), (2, 3, 1, 4)) * 0.5 + del tmp28 + rdm2.vooo = tmp1.transpose((3, 2, 1, 0)).copy() rdm2.vooo += einsum(delta.oo, (0, 1), l1, (2, 3), (2, 0, 3, 1)) rdm2.vooo += einsum(l1, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -1 - del delta - rdm2.oovv += t2 - rdm2.oovv += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 1, 3)) * -1 - rdm2.oovv += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) - rdm2.ovov += einsum(t1, (0, 1), l1, (2, 3), (0, 2, 3, 1)) * -1 - rdm2.ovvo += einsum(t1, (0, 1), l1, (2, 3), (0, 2, 1, 3)) - rdm2.voov += einsum(t1, (0, 1), l1, (2, 3), (2, 0, 3, 1)) - rdm2.vovo += einsum(t1, (0, 1), l1, (2, 3), (2, 0, 1, 3)) * -1 - rdm2.vvoo = l2.copy() - rdm2.vvvv += einsum(t2, (0, 1, 2, 3), l2, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + rdm2.ovoo = tmp1.transpose((2, 3, 1, 0)).copy() * -1 + del tmp1 + rdm2.ovoo += einsum(delta.oo, (0, 1), l1, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.ovoo += einsum(l1, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) + rdm2.oovo = tmp5.transpose((2, 1, 3, 0)).copy() + rdm2.oovo += tmp6.transpose((1, 2, 3, 0)) + rdm2.oovo += tmp6.transpose((2, 1, 3, 0)) * -1 + rdm2.oovo += einsum(t1, (0, 1), tmp3, (2, 3), (0, 3, 1, 2)) * -0.5 + rdm2.oovo += einsum(t1, (0, 1), tmp3, (2, 3), (3, 0, 1, 2)) * 0.5 + rdm2.oovo += einsum(delta.oo, (0, 1), tmp16, (2, 3), (2, 0, 3, 1)) * -1 + rdm2.oovo += einsum(tmp16, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) + del tmp16 + rdm2.oovo += einsum(t1, (0, 1), delta.oo, (2, 3), (0, 2, 1, 3)) + rdm2.oovo += einsum(delta.oo, (0, 1), t1, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.oovo += einsum(t1, (0, 1), tmp4, (2, 3), (0, 3, 1, 2)) * -1 + rdm2.oovo += einsum(t1, (0, 1), tmp4, (2, 3), (3, 0, 1, 2)) + rdm2.oovo += einsum(t1, (0, 1), tmp17, (0, 2, 3, 4), (4, 3, 1, 2)) * 0.5 + del tmp17 + rdm2.ooov = tmp5.transpose((2, 1, 0, 3)).copy() * -1 + del tmp5 + rdm2.ooov += tmp6.transpose((1, 2, 0, 3)) * -1 + rdm2.ooov += tmp6.transpose((2, 1, 0, 3)) + del tmp6 + rdm2.ooov += einsum(t1, (0, 1), tmp3, (2, 3), (0, 3, 2, 1)) * 0.5 + rdm2.ooov += einsum(t1, (0, 1), tmp3, (2, 3), (3, 0, 2, 1)) * -0.5 + rdm2.ooov += einsum(tmp9, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.ooov += einsum(tmp9, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) + del tmp9 + rdm2.ooov += einsum(t1, (0, 1), delta.oo, (2, 3), (0, 2, 3, 1)) * -1 + rdm2.ooov += einsum(delta.oo, (0, 1), t1, (2, 3), (0, 2, 1, 3)) + rdm2.ooov += einsum(delta.oo, (0, 1), tmp12, (2, 3), (2, 0, 1, 3)) * 0.5 + rdm2.ooov += einsum(tmp12, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) * -0.5 + del tmp12 + rdm2.ooov += einsum(t1, (0, 1), tmp4, (2, 3), (0, 3, 2, 1)) + rdm2.ooov += einsum(t1, (0, 1), tmp4, (2, 3), (3, 0, 2, 1)) * -1 + rdm2.ooov += einsum(tmp13, (0, 1, 2, 3), t1, (0, 4), (3, 2, 1, 4)) * -1 + del tmp13 + rdm2.oooo = tmp0.transpose((3, 2, 1, 0)).copy() * 0.5 + del tmp0 + rdm2.oooo += tmp2.transpose((2, 3, 1, 0)) * -1 + del tmp2 + rdm2.oooo += einsum(delta.oo, (0, 1), tmp3, (2, 3), (3, 0, 2, 1)) * -0.5 + rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (2, 1, 0, 3)) * 0.5 + rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (1, 2, 3, 0)) * 0.5 + rdm2.oooo += einsum(tmp3, (0, 1), delta.oo, (2, 3), (2, 1, 3, 0)) * -0.5 + del tmp3 + rdm2.oooo += einsum(delta.oo, (0, 1), delta.oo, (2, 3), (2, 0, 3, 1)) + rdm2.oooo += einsum(delta.oo, (0, 1), delta.oo, (2, 3), (2, 0, 1, 3)) * -1 + rdm2.oooo += einsum(delta.oo, (0, 1), tmp4, (2, 3), (3, 0, 2, 1)) * -1 + rdm2.oooo += einsum(tmp4, (0, 1), delta.oo, (2, 3), (2, 1, 0, 3)) + rdm2.oooo += einsum(tmp4, (0, 1), delta.oo, (2, 3), (1, 2, 3, 0)) + rdm2.oooo += einsum(delta.oo, (0, 1), tmp4, (2, 3), (0, 3, 1, 2)) * -1 + del tmp4, delta rdm2 = pack_2e(rdm2.oooo, rdm2.ooov, rdm2.oovo, rdm2.ovoo, rdm2.vooo, rdm2.oovv, rdm2.ovov, rdm2.ovvo, rdm2.voov, rdm2.vovo, rdm2.vvoo, rdm2.ovvv, rdm2.vovv, rdm2.vvov, rdm2.vvvo, rdm2.vvvv) rdm2 = rdm2.swapaxes(1, 2) @@ -734,7 +731,7 @@ def make_rdm2_f(l1=None, l2=None, t1=None, t2=None, **kwargs): def hbar_matvec_ip_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:57.675693. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:29.633369. Parameters ---------- @@ -788,49 +785,49 @@ def hbar_matvec_ip_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): tmp8 : array """ - tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) - tmp13 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) - tmp1 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) - tmp45 = einsum(t1, (0, 1), tmp1, (0, 2), (2, 1)) - tmp2 = einsum(v.oovv, (0, 1, 2, 3), t1, (1, 3), (0, 2)) - tmp39 = einsum(tmp2, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 - tmp38 = einsum(t2, (0, 1, 2, 3), tmp2, (1, 3), (0, 2)) - tmp5 = einsum(tmp2, (0, 1), t1, (2, 1), (2, 0)) - tmp55 = einsum(t1, (0, 1), tmp5, (2, 0), (2, 1)) tmp3 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp2 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) tmp52 = einsum(t1, (0, 1), tmp3, (2, 3, 4, 1), (2, 0, 4, 3)) - tmp56 = einsum(tmp52, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) - tmp41 = einsum(tmp3, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) - tmp40 = einsum(t2, (0, 1, 2, 3), tmp3, (4, 1, 0, 3), (4, 2)) - tmp4 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) - tmp43 = einsum(t1, (0, 1), tmp4, (2, 0), (2, 1)) - tmp7 = einsum(t1, (0, 1), f.oo, (2, 0), (2, 1)) - tmp8 = einsum(t1, (0, 1), f.vv, (2, 1), (0, 2)) - tmp11 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - tmp12 = einsum(f.ov, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) - tmp15 = einsum(v.oooo, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) - tmp16 = einsum(v.ovov, (0, 1, 2, 3), t1, (2, 1), (0, 3)) - tmp17 = einsum(t1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) - tmp20 = einsum(v.ooov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp46 = einsum(tmp20, (0, 1, 2, 3), t1, (1, 4), (0, 2, 3, 4)) * -1 + tmp5 = einsum(t1, (0, 1), tmp2, (2, 1), (0, 2)) + tmp25 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) tmp24 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) - tmp48 = einsum(t1, (0, 1), tmp24, (2, 1), (0, 2)) - tmp25 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp49 = einsum(tmp25, (0, 1, 2, 3), t1, (4, 3), (0, 4, 1, 2)) * -1 - tmp27 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) - tmp28 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) - tmp30 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) - tmp31 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) - tmp33 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp20 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp1 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) + tmp33 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp4 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 2, 3), (4, 0)) + tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp56 = einsum(t1, (0, 1), tmp52, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp55 = einsum(tmp5, (0, 1), t1, (1, 2), (0, 2)) + tmp49 = einsum(t1, (0, 1), tmp25, (2, 3, 4, 1), (2, 0, 3, 4)) * -1 + tmp48 = einsum(tmp24, (0, 1), t1, (2, 1), (2, 0)) + tmp46 = einsum(t1, (0, 1), tmp20, (2, 0, 3, 4), (2, 3, 4, 1)) * -1 + tmp45 = einsum(tmp1, (0, 1), t1, (0, 2), (1, 2)) tmp44 = einsum(tmp33, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) * -1 - tmp34 = einsum(t2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp35 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp43 = einsum(tmp4, (0, 1), t1, (1, 2), (0, 2)) + tmp41 = einsum(t2, (0, 1, 2, 3), tmp3, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp40 = einsum(t2, (0, 1, 2, 3), tmp3, (4, 1, 0, 3), (4, 2)) + tmp39 = einsum(tmp2, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + tmp38 = einsum(tmp2, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp35 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp34 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp31 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp30 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) + tmp28 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) + tmp27 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) + tmp17 = einsum(v.ovov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 2, 1)) + tmp16 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp15 = einsum(t1, (0, 1), v.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp13 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) + tmp12 = einsum(t2, (0, 1, 2, 3), f.ov, (4, 3), (4, 0, 1, 2)) + tmp11 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp8 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp7 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) return {f"tmp0": tmp0, f"tmp1": tmp1, f"tmp11": tmp11, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp15": tmp15, f"tmp16": tmp16, f"tmp17": tmp17, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp24": tmp24, f"tmp25": tmp25, f"tmp27": tmp27, f"tmp28": tmp28, f"tmp3": tmp3, f"tmp30": tmp30, f"tmp31": tmp31, f"tmp33": tmp33, f"tmp34": tmp34, f"tmp35": tmp35, f"tmp38": tmp38, f"tmp39": tmp39, f"tmp4": tmp4, f"tmp40": tmp40, f"tmp41": tmp41, f"tmp43": tmp43, f"tmp44": tmp44, f"tmp45": tmp45, f"tmp46": tmp46, f"tmp48": tmp48, f"tmp49": tmp49, f"tmp5": tmp5, f"tmp52": tmp52, f"tmp55": tmp55, f"tmp56": tmp56, f"tmp7": tmp7, f"tmp8": tmp8} def hbar_matvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:47:57.694359. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:29.648997. Parameters ---------- @@ -856,40 +853,37 @@ def hbar_matvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) """ ints = kwargs["ints"] - tmp10 = einsum(r2, (0, 1, 2), v.ooov, (3, 1, 4, 2), (0, 3, 4)) - tmp9 = einsum(ints.tmp3, (0, 1, 2, 3), r2, (4, 1, 3), (0, 2, 4)) - tmp11 = tmp9.copy() - del tmp9 - tmp11 += tmp10 * -1 - del tmp10 + tmp10 = einsum(v.ooov, (0, 1, 2, 3), r2, (4, 1, 3), (4, 0, 2)) + tmp9 = einsum(r2, (0, 1, 2), ints.tmp3, (3, 1, 4, 2), (3, 4, 0)) tmp7 = ints.tmp25.copy() tmp7 += ints.tmp35 tmp13 = ints.tmp41.copy() tmp13 += ints.tmp46.transpose((0, 2, 1, 3)) + tmp11 = tmp9.copy() + del tmp9 + tmp11 += tmp10 * -1 + del tmp10 + tmp18 = ints.tmp17.copy() + tmp18 += ints.tmp28 tmp16 = f.oo.copy() tmp16 += ints.tmp0 tmp16 += ints.tmp1 tmp16 += ints.tmp5.transpose((1, 0)) - tmp18 = ints.tmp17.copy() - tmp18 += ints.tmp28 - tmp4 = einsum(r2, (0, 1, 2), ints.tmp4, (3, 1), (3, 0, 2)) - tmp12 = einsum(t1, (0, 1), tmp11, (2, 0, 3), (2, 3, 1)) - del tmp11 tmp8 = einsum(tmp7, (0, 1, 2, 3), r2, (4, 1, 3), (0, 4, 2)) * -1 del tmp7 + tmp4 = einsum(r2, (0, 1, 2), ints.tmp4, (3, 1), (3, 0, 2)) + tmp5 = einsum(r2, (0, 1, 2), ints.tmp20, (3, 1, 0, 4), (3, 4, 2)) * -1 tmp14 = einsum(tmp13, (0, 1, 2, 3), r1, (2,), (0, 1, 3)) del tmp13 - tmp5 = einsum(r2, (0, 1, 2), ints.tmp20, (3, 1, 0, 4), (3, 4, 2)) * -1 - tmp6 = einsum(v.ovov, (0, 1, 2, 3), r2, (4, 2, 1), (4, 0, 3)) + tmp6 = einsum(r2, (0, 1, 2), v.ovov, (3, 2, 1, 4), (0, 3, 4)) + tmp12 = einsum(t1, (0, 1), tmp11, (2, 0, 3), (2, 3, 1)) + del tmp11 tmp22 = f.ov.copy() tmp22 += ints.tmp2 - tmp17 = einsum(r2, (0, 1, 2), tmp16, (1, 3), (3, 0, 2)) * -1 - del tmp16 - tmp19 = einsum(tmp18, (0, 1, 2, 3), r1, (1,), (0, 2, 3)) + tmp19 = einsum(r1, (0,), tmp18, (1, 0, 2, 3), (1, 2, 3)) del tmp18 - tmp3 = einsum(v.oovv, (0, 1, 2, 3), r2, (0, 1, 3), (2,)) - r2new = einsum(tmp3, (0,), t2, (1, 2, 3, 0), (1, 2, 3)) * 0.5 - del tmp3 + tmp17 = einsum(tmp16, (0, 1), r2, (2, 0, 3), (1, 2, 3)) * -1 + del tmp16 tmp24 = ints.tmp12.copy() tmp24 += ints.tmp15.transpose((2, 0, 1, 3)) tmp24 += ints.tmp44.transpose((2, 0, 1, 3)) * 0.5 @@ -898,8 +892,6 @@ def hbar_matvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp24 += ints.tmp39.transpose((2, 0, 1, 3)) * -1 tmp24 += ints.tmp56.transpose((2, 1, 0, 3)) * -1 tmp24 += v.ovoo.transpose((0, 2, 3, 1)) * -1 - r2new += einsum(tmp24, (0, 1, 2, 3), r1, (0,), (2, 1, 3)) * -1 - del tmp24 tmp15 = tmp4.copy() * -0.5 del tmp4 tmp15 += tmp5 * 0.5 @@ -912,28 +904,19 @@ def hbar_matvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) del tmp12 tmp15 += tmp14 del tmp14 - r2new += tmp15.transpose((1, 0, 2)) - r2new += tmp15 * -1 - del tmp15 - tmp21 = ints.tmp33.copy() * 0.5 - tmp21 += ints.tmp52 - tmp21 += v.oooo - r2new += einsum(r2, (0, 1, 2), tmp21, (3, 4, 0, 1), (3, 4, 2)) * 0.5 - del tmp21 + tmp3 = einsum(r2, (0, 1, 2), v.oovv, (0, 1, 3, 2), (3,)) tmp23 = ints.tmp24.transpose((1, 0)).copy() tmp23 += ints.tmp34.transpose((1, 0)) * 0.5 tmp23 += f.vv * -1 - tmp23 += einsum(tmp22, (0, 1), t1, (0, 2), (1, 2)) + tmp23 += einsum(t1, (0, 1), tmp22, (0, 2), (2, 1)) del tmp22 - r2new += einsum(r2, (0, 1, 2), tmp23, (2, 3), (0, 1, 3)) * -1 - del tmp23 + tmp21 = ints.tmp33.copy() * 0.5 + tmp21 += ints.tmp52 + tmp21 += v.oooo tmp20 = tmp17.copy() * -1 del tmp17 tmp20 += tmp19 del tmp19 - r2new += tmp20.transpose((1, 0, 2)) * -1 - r2new += tmp20 - del tmp20 tmp25 = ints.tmp13.copy() tmp25 += ints.tmp16 tmp25 += ints.tmp27 * 0.5 @@ -948,30 +931,44 @@ def hbar_matvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp25 += ints.tmp11 * -1 tmp25 += ints.tmp38 * -1 tmp25 += ints.tmp8 * -1 - r2new += einsum(tmp25, (0, 1), r1, (2,), (0, 2, 1)) - r2new += einsum(tmp25, (0, 1), r1, (2,), (2, 0, 1)) * -1 - del tmp25 - tmp1 = f.ov.copy() - tmp1 += ints.tmp2 - r1new = einsum(r2, (0, 1, 2), tmp1, (1, 2), (0,)) - del tmp1 - tmp0 = ints.tmp3.copy() - tmp0 += v.ovoo.transpose((0, 2, 3, 1)) * -1 - r1new += einsum(tmp0, (0, 1, 2, 3), r2, (2, 1, 3), (0,)) * -0.5 - del tmp0 tmp2 = f.oo.copy() * 2 tmp2 += ints.tmp0 * 2 tmp2 += ints.tmp1 * 2 tmp2 += ints.tmp4.transpose((1, 0)) tmp2 += ints.tmp5.transpose((1, 0)) * 2 - r1new += einsum(tmp2, (0, 1), r1, (0,), (1,)) * -0.5 + tmp0 = ints.tmp3.copy() + tmp0 += v.ovoo.transpose((0, 2, 3, 1)) * -1 + tmp1 = f.ov.copy() + tmp1 += ints.tmp2 + r2new = einsum(tmp3, (0,), t2, (1, 2, 3, 0), (1, 2, 3)) * 0.5 + del tmp3 + r2new += tmp15 * -1 + r2new += tmp15.transpose((1, 0, 2)) + del tmp15 + r2new += tmp20 + r2new += tmp20.transpose((1, 0, 2)) * -1 + del tmp20 + r2new += einsum(r2, (0, 1, 2), tmp21, (3, 4, 0, 1), (3, 4, 2)) * 0.5 + del tmp21 + r2new += einsum(r2, (0, 1, 2), tmp23, (2, 3), (0, 1, 3)) * -1 + del tmp23 + r2new += einsum(tmp24, (0, 1, 2, 3), r1, (0,), (2, 1, 3)) * -1 + del tmp24 + r2new += einsum(r1, (0,), tmp25, (1, 2), (0, 1, 2)) * -1 + r2new += einsum(r1, (0,), tmp25, (1, 2), (1, 0, 2)) + del tmp25 + r1new = einsum(r2, (0, 1, 2), tmp0, (3, 1, 0, 2), (3,)) * -0.5 + del tmp0 + r1new += einsum(tmp1, (0, 1), r2, (2, 0, 1), (2,)) + del tmp1 + r1new += einsum(r1, (0,), tmp2, (0, 1), (1,)) * -0.5 del tmp2 return {f"r1new": r1new, f"r2new": r2new} def hbar_matvec_ea_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:48:07.395341. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:37.973150. Parameters ---------- @@ -1015,39 +1012,39 @@ def hbar_matvec_ea_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): tmp9 : array """ + tmp2 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp50 = einsum(t1, (0, 1), tmp2, (2, 1), (0, 2)) tmp1 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) - tmp47 = einsum(tmp1, (0, 1), t1, (2, 1), (2, 0)) - tmp2 = einsum(v.oovv, (0, 1, 2, 3), t1, (1, 3), (0, 2)) - tmp50 = einsum(tmp2, (0, 1), t1, (2, 1), (2, 0)) - tmp56 = einsum(t1, (0, 1), tmp50, (2, 0), (2, 1)) - tmp37 = einsum(t2, (0, 1, 2, 3), tmp2, (1, 3), (0, 2)) - tmp4 = einsum(t2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp7 = einsum(t1, (0, 1), f.oo, (2, 0), (2, 1)) - tmp8 = einsum(t1, (0, 1), f.vv, (2, 1), (0, 2)) - tmp9 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) - tmp13 = einsum(t1, (0, 1), tmp9, (0, 2), (2, 1)) - tmp12 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - tmp15 = einsum(v.ovov, (0, 1, 2, 3), t1, (2, 1), (0, 3)) - tmp18 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) tmp19 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) - tmp44 = einsum(tmp19, (0, 1), t1, (0, 2), (1, 2)) - tmp23 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp27 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) - tmp28 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) - tmp29 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) - tmp30 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 5, 3), (4, 5, 1, 2)) - tmp32 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) - tmp41 = einsum(tmp32, (0, 1), t1, (1, 2), (0, 2)) - tmp34 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp32 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 2, 3), (4, 0)) tmp38 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp9 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp56 = einsum(t1, (0, 1), tmp50, (2, 0), (2, 1)) + tmp47 = einsum(t1, (0, 1), tmp1, (2, 1), (0, 2)) + tmp44 = einsum(t1, (0, 1), tmp19, (0, 2), (2, 1)) + tmp41 = einsum(t1, (0, 1), tmp32, (2, 0), (2, 1)) tmp40 = einsum(t2, (0, 1, 2, 3), tmp38, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 tmp39 = einsum(t2, (0, 1, 2, 3), tmp38, (4, 1, 0, 3), (4, 2)) + tmp37 = einsum(tmp2, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp34 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp30 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp29 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) + tmp28 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) + tmp27 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) + tmp23 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp18 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp15 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp13 = einsum(tmp9, (0, 1), t1, (0, 2), (1, 2)) + tmp12 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp8 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp7 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + tmp4 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) return {f"tmp1": tmp1, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp15": tmp15, f"tmp18": tmp18, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp23": tmp23, f"tmp27": tmp27, f"tmp28": tmp28, f"tmp29": tmp29, f"tmp30": tmp30, f"tmp32": tmp32, f"tmp34": tmp34, f"tmp37": tmp37, f"tmp38": tmp38, f"tmp39": tmp39, f"tmp4": tmp4, f"tmp40": tmp40, f"tmp41": tmp41, f"tmp44": tmp44, f"tmp47": tmp47, f"tmp50": tmp50, f"tmp56": tmp56, f"tmp7": tmp7, f"tmp8": tmp8, f"tmp9": tmp9} def hbar_matvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:48:07.409722. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:37.985692. Parameters ---------- @@ -1077,51 +1074,39 @@ def hbar_matvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp13 += v.ovoo.transpose((0, 2, 3, 1)) * -1 tmp0 = f.ov.copy() tmp0 += ints.tmp2 - r1new = einsum(r2, (0, 1, 2), tmp0, (2, 1), (0,)) - tmp14 = einsum(tmp13, (0, 1, 2, 3), r2, (4, 3, 1), (0, 2, 4)) * -1 + tmp14 = einsum(r2, (0, 1, 2), tmp13, (3, 2, 4, 1), (3, 4, 0)) * -1 tmp15 = einsum(r2, (0, 1, 2), tmp0, (3, 1), (2, 3, 0)) * -1 - tmp5 = einsum(r2, (0, 1, 2), v.oovv, (3, 4, 0, 1), (2, 3, 4)) - r2new = einsum(t2, (0, 1, 2, 3), tmp5, (4, 1, 0), (2, 3, 4)) * -0.25 tmp8 = r2.transpose((2, 0, 1)).copy() tmp8 += einsum(r1, (0,), t1, (1, 2), (1, 0, 2)) - tmp9 = ints.tmp23.copy() - tmp9 += ints.tmp34 - tmp11 = f.vv.copy() * 2 - tmp11 += ints.tmp4.transpose((1, 0)) * -1 tmp16 = tmp14.transpose((1, 0, 2)).copy() * -1 del tmp14 tmp16 += tmp15.transpose((1, 0, 2)) * -1 del tmp15 + tmp9 = ints.tmp23.copy() + tmp9 += ints.tmp34 + tmp11 = f.vv.copy() * 2 + tmp11 += ints.tmp4.transpose((1, 0)) * -1 tmp6 = einsum(v.ovvv, (0, 1, 2, 3), r2, (2, 3, 4), (4, 0, 1)) - tmp3 = einsum(r1, (0,), tmp0, (1, 0), (1,)) - del tmp0 - tmp2 = einsum(v.oovv, (0, 1, 2, 3), r2, (2, 3, 1), (0,)) - tmp25 = tmp5.transpose((0, 2, 1)).copy() * -0.5 - del tmp5 - tmp25 += einsum(r1, (0,), tmp13, (1, 2, 3, 0), (1, 2, 3)) - del tmp13 - tmp21 = einsum(ints.tmp30, (0, 1, 2, 3), r1, (3,), (0, 1, 2)) - tmp20 = einsum(ints.tmp1, (0, 1), r2, (2, 1, 3), (3, 0, 2)) + tmp5 = einsum(r2, (0, 1, 2), v.oovv, (3, 4, 0, 1), (2, 3, 4)) + tmp18 = einsum(v.ovov, (0, 1, 2, 3), tmp8, (2, 1, 4), (0, 4, 3)) + tmp17 = einsum(t1, (0, 1), tmp16, (0, 2, 3), (2, 3, 1)) + del tmp16 tmp10 = einsum(tmp9, (0, 1, 2, 3), tmp8, (1, 3, 4), (0, 2, 4)) - del tmp9 - tmp12 = einsum(r2, (0, 1, 2), tmp11, (1, 3), (2, 3, 0)) * -0.5 + del tmp8, tmp9 + tmp12 = einsum(tmp11, (0, 1), r2, (2, 0, 3), (3, 1, 2)) * -0.5 del tmp11 - tmp17 = einsum(tmp16, (0, 1, 2), t1, (0, 3), (1, 2, 3)) - del tmp16 - tmp7 = einsum(t1, (0, 1), tmp6, (2, 0, 3), (2, 1, 3)) + tmp7 = einsum(tmp6, (0, 1, 2), t1, (1, 3), (0, 3, 2)) del tmp6 - tmp18 = einsum(v.ovov, (0, 1, 2, 3), tmp8, (2, 1, 4), (0, 4, 3)) - del tmp8 - tmp4 = tmp2.copy() * 0.5 - del tmp2 - tmp4 += tmp3 - del tmp3 - r2new += einsum(tmp4, (0,), t2, (1, 0, 2, 3), (2, 3, 1)) - r1new += einsum(tmp4, (0,), t1, (0, 1), (1,)) * -1 - del tmp4 - tmp27 = ints.tmp13.copy() - tmp27 += ints.tmp15 - tmp27 += ints.tmp27 * 0.5 + tmp21 = einsum(ints.tmp30, (0, 1, 2, 3), r1, (3,), (0, 1, 2)) + tmp20 = einsum(ints.tmp1, (0, 1), r2, (2, 1, 3), (3, 0, 2)) + tmp2 = einsum(r2, (0, 1, 2), v.oovv, (3, 2, 0, 1), (3,)) + tmp3 = einsum(tmp0, (0, 1), r1, (1,), (0,)) + tmp25 = tmp5.transpose((0, 2, 1)).copy() * -0.5 + tmp25 += einsum(r1, (0,), tmp13, (1, 2, 3, 0), (1, 2, 3)) + del tmp13 + tmp27 = ints.tmp13.copy() + tmp27 += ints.tmp15 + tmp27 += ints.tmp27 * 0.5 tmp27 += ints.tmp29 * 0.5 tmp27 += ints.tmp39 * 0.5 tmp27 += ints.tmp41 * 0.5 @@ -1133,27 +1118,11 @@ def hbar_matvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp27 += ints.tmp12 * -1 tmp27 += ints.tmp37 * -1 tmp27 += ints.tmp8 * -1 - r2new += einsum(tmp27, (0, 1), r1, (2,), (1, 2, 0)) - r2new += einsum(r1, (0,), tmp27, (1, 2), (0, 2, 1)) * -1 - del tmp27 - tmp26 = einsum(tmp25, (0, 1, 2), t1, (1, 3), (0, 2, 3)) * 2 - del tmp25 - r2new += einsum(tmp26, (0, 1, 2), t1, (1, 3), (3, 2, 0)) * -0.5 - del tmp26 - tmp22 = tmp20.copy() - del tmp20 - tmp22 += tmp21 - del tmp21 - r2new += tmp22.transpose((2, 1, 0)) * -1 - r2new += tmp22.transpose((1, 2, 0)) - del tmp22 tmp24 = f.oo.copy() tmp24 += ints.tmp19 tmp24 += ints.tmp32.transpose((1, 0)) * 0.5 tmp24 += ints.tmp50.transpose((1, 0)) tmp24 += ints.tmp9 - r2new += einsum(tmp24, (0, 1), r2, (2, 3, 0), (2, 3, 1)) * -1 - del tmp24 tmp19 = tmp7.copy() * 0.5 del tmp7 tmp19 += tmp10 * -1 @@ -1164,28 +1133,55 @@ def hbar_matvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) del tmp17 tmp19 += tmp18 * -1 del tmp18 - r2new += tmp19.transpose((2, 1, 0)) - r2new += tmp19.transpose((1, 2, 0)) * -1 - del tmp19 + tmp22 = tmp20.copy() + del tmp20 + tmp22 += tmp21 + del tmp21 tmp23 = ints.tmp18.copy() tmp23 += ints.tmp40 * 0.5 tmp23 += ints.tmp28 * -0.5 tmp23 += v.ovvv.transpose((0, 2, 3, 1)) * -1 - r2new += einsum(tmp23, (0, 1, 2, 3), r1, (3,), (2, 1, 0)) * -1 - del tmp23 + tmp4 = tmp2.copy() * 0.5 + del tmp2 + tmp4 += tmp3 + del tmp3 + tmp26 = einsum(t1, (0, 1), tmp25, (2, 3, 0), (2, 3, 1)) * 2 + del tmp25 tmp1 = ints.tmp1.transpose((1, 0)).copy() tmp1 += ints.tmp4.transpose((1, 0)) * 0.5 tmp1 += f.vv * -1 + r2new = einsum(tmp5, (0, 1, 2), t2, (2, 1, 3, 4), (3, 4, 0)) * -0.25 + del tmp5 + r2new += einsum(v.vvvv, (0, 1, 2, 3), r2, (2, 3, 4), (0, 1, 4)) * 0.5 + r2new += tmp19.transpose((1, 2, 0)) * -1 + r2new += tmp19.transpose((2, 1, 0)) + del tmp19 + r2new += tmp22.transpose((1, 2, 0)) + r2new += tmp22.transpose((2, 1, 0)) * -1 + del tmp22 + r2new += einsum(tmp23, (0, 1, 2, 3), r1, (3,), (2, 1, 0)) * -1 + del tmp23 + r2new += einsum(r2, (0, 1, 2), tmp24, (2, 3), (0, 1, 3)) * -1 + del tmp24 + r2new += einsum(tmp4, (0,), t2, (1, 0, 2, 3), (2, 3, 1)) + r2new += einsum(t1, (0, 1), tmp26, (2, 0, 3), (3, 1, 2)) * -0.5 + del tmp26 + r2new += einsum(tmp27, (0, 1), r1, (2,), (2, 1, 0)) * -1 + r2new += einsum(tmp27, (0, 1), r1, (2,), (1, 2, 0)) + del tmp27 + r1new = einsum(v.ovvv, (0, 1, 2, 3), r2, (2, 3, 0), (1,)) * -0.5 + r1new += einsum(r2, (0, 1, 2), tmp0, (2, 1), (0,)) + del tmp0 r1new += einsum(tmp1, (0, 1), r1, (0,), (1,)) * -1 del tmp1 - r1new += einsum(v.ovvv, (0, 1, 2, 3), r2, (2, 3, 0), (1,)) * -0.5 - r2new += einsum(v.vvvv, (0, 1, 2, 3), r2, (2, 3, 4), (0, 1, 4)) * 0.5 + r1new += einsum(t1, (0, 1), tmp4, (0,), (1,)) * -1 + del tmp4 return {f"r1new": r1new, f"r2new": r2new} def hbar_matvec_ee_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:48:29.173269. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:56.696839. Parameters ---------- @@ -1243,53 +1239,53 @@ def hbar_matvec_ee_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): tmp94 : array """ - tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) - tmp26 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) - tmp2 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) - tmp87 = einsum(tmp2, (0, 1), t1, (0, 2), (1, 2)) + tmp7 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp6 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp101 = einsum(t1, (0, 1), tmp7, (2, 3, 4, 1), (2, 0, 4, 3)) + tmp12 = einsum(t1, (0, 1), tmp6, (2, 1), (0, 2)) + tmp5 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) tmp4 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) - tmp93 = einsum(tmp4, (0, 1), t1, (2, 1), (2, 0)) - tmp5 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp94 = einsum(tmp5, (0, 1, 2, 3), t1, (4, 3), (0, 4, 1, 2)) * -1 - tmp6 = einsum(v.oovv, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp40 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp2 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) + tmp62 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp9 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 2, 3), (4, 0)) + tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp106 = einsum(t1, (0, 1), tmp101, (2, 3, 0, 4), (2, 3, 4, 1)) * -1 + tmp105 = einsum(t1, (0, 1), tmp12, (2, 0), (2, 1)) + tmp94 = einsum(t1, (0, 1), tmp5, (2, 3, 4, 1), (2, 0, 3, 4)) * -1 + tmp93 = einsum(t1, (0, 1), tmp4, (2, 1), (0, 2)) + tmp88 = einsum(tmp40, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + tmp87 = einsum(t1, (0, 1), tmp2, (0, 2), (2, 1)) + tmp81 = einsum(tmp62, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp80 = einsum(t1, (0, 1), tmp9, (2, 0), (2, 1)) + tmp77 = einsum(tmp7, (0, 1, 2, 3), t2, (2, 1, 4, 5), (0, 4, 5, 3)) * -1 + tmp75 = einsum(t2, (0, 1, 2, 3), tmp7, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp74 = einsum(tmp7, (0, 1, 2, 3), t2, (2, 1, 4, 3), (0, 4)) tmp71 = einsum(tmp6, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 tmp70 = einsum(tmp6, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - tmp12 = einsum(tmp6, (0, 1), t1, (2, 1), (2, 0)) - tmp105 = einsum(t1, (0, 1), tmp12, (2, 0), (2, 1)) - tmp7 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp101 = einsum(t1, (0, 1), tmp7, (2, 3, 4, 1), (2, 0, 4, 3)) - tmp106 = einsum(tmp101, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) * -1 - tmp77 = einsum(t2, (0, 1, 2, 3), tmp7, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 - tmp75 = einsum(tmp7, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) - tmp74 = einsum(t2, (0, 1, 2, 3), tmp7, (4, 1, 0, 3), (4, 2)) - tmp9 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) - tmp80 = einsum(tmp9, (0, 1), t1, (1, 2), (0, 2)) - tmp10 = einsum(t2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp17 = einsum(t1, (0, 1), f.oo, (2, 0), (2, 1)) - tmp18 = einsum(t1, (0, 1), f.vv, (2, 1), (0, 2)) - tmp22 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - tmp23 = einsum(f.ov, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) - tmp30 = einsum(v.oooo, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) - tmp32 = einsum(v.ovov, (0, 1, 2, 3), t1, (2, 1), (0, 3)) - tmp33 = einsum(t1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) - tmp37 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp40 = einsum(v.ooov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) - tmp88 = einsum(t1, (0, 1), tmp40, (2, 3, 0, 4), (2, 3, 4, 1)) - tmp48 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) - tmp49 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) - tmp51 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) + tmp64 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp57 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp55 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 5, 2, 3), (0, 1, 4, 5)) tmp54 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) - tmp55 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) - tmp57 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 5, 3), (4, 5, 1, 2)) - tmp62 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 5, 2, 3), (0, 1, 4, 5)) - tmp81 = einsum(tmp62, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) - tmp64 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp51 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) + tmp49 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) + tmp48 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 3, 0, 1), (4, 2)) + tmp37 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp33 = einsum(v.ovov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 2, 1)) + tmp32 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp30 = einsum(t1, (0, 1), v.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp26 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) + tmp23 = einsum(t2, (0, 1, 2, 3), f.ov, (4, 3), (4, 0, 1, 2)) + tmp22 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp18 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp17 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + tmp10 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) return {f"tmp0": tmp0, f"tmp10": tmp10, f"tmp101": tmp101, f"tmp105": tmp105, f"tmp106": tmp106, f"tmp12": tmp12, f"tmp17": tmp17, f"tmp18": tmp18, f"tmp2": tmp2, f"tmp22": tmp22, f"tmp23": tmp23, f"tmp26": tmp26, f"tmp30": tmp30, f"tmp32": tmp32, f"tmp33": tmp33, f"tmp37": tmp37, f"tmp4": tmp4, f"tmp40": tmp40, f"tmp48": tmp48, f"tmp49": tmp49, f"tmp5": tmp5, f"tmp51": tmp51, f"tmp54": tmp54, f"tmp55": tmp55, f"tmp57": tmp57, f"tmp6": tmp6, f"tmp62": tmp62, f"tmp64": tmp64, f"tmp7": tmp7, f"tmp70": tmp70, f"tmp71": tmp71, f"tmp74": tmp74, f"tmp75": tmp75, f"tmp77": tmp77, f"tmp80": tmp80, f"tmp81": tmp81, f"tmp87": tmp87, f"tmp88": tmp88, f"tmp9": tmp9, f"tmp93": tmp93, f"tmp94": tmp94} def hbar_matvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): """ - Code generated by `albert` 0.0.0 on 2024-08-12T21:48:29.204697. + Code generated by `albert` 0.0.0 on 2024-08-13T22:13:56.718457. Parameters ---------- @@ -1317,151 +1313,112 @@ def hbar_matvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) ints = kwargs["ints"] tmp2 = f.ov.copy() tmp2 += ints.tmp6 - r1new = einsum(r2, (0, 1, 2, 3), tmp2, (1, 3), (0, 2)) - tmp13 = ints.tmp5.copy() - tmp13 += ints.tmp64 tmp0 = einsum(v.oovv, (0, 1, 2, 3), r1, (1, 3), (0, 2)) - r1new += einsum(tmp0, (0, 1), t2, (2, 0, 3, 1), (2, 3)) - tmp41 = einsum(ints.tmp7, (0, 1, 2, 3), r1, (1, 3), (0, 2)) - tmp7 = einsum(tmp2, (0, 1), r1, (2, 1), (0, 2)) - tmp6 = einsum(v.oovv, (0, 1, 2, 3), r2, (4, 1, 2, 3), (4, 0)) - tmp35 = einsum(r1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) - tmp17 = einsum(tmp13, (0, 1, 2, 3), r1, (4, 3), (0, 1, 4, 2)) - tmp15 = einsum(r2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) - tmp16 = einsum(r2, (0, 1, 2, 3), ints.tmp7, (4, 1, 5, 3), (4, 5, 0, 2)) - tmp28 = einsum(v.ovvv, (0, 1, 2, 3), r2, (4, 5, 2, 3), (4, 5, 0, 1)) - tmp29 = einsum(t2, (0, 1, 2, 3), tmp0, (4, 3), (0, 1, 4, 2)) * -1 - del tmp0 - tmp5 = f.oo.copy() - tmp5 += ints.tmp0 - tmp5 += ints.tmp12.transpose((1, 0)) - tmp5 += ints.tmp2 - tmp5 += ints.tmp9.transpose((1, 0)) * 0.5 - r1new += einsum(tmp5, (0, 1), r1, (0, 2), (1, 2)) * -1 - tmp42 = tmp41.copy() + tmp39 = ints.tmp5.copy() + tmp39 += ints.tmp64 + tmp25 = einsum(v.ooov, (0, 1, 2, 3), r1, (4, 3), (4, 0, 1, 2)) + tmp6 = einsum(r1, (0, 1), tmp2, (2, 1), (2, 0)) + tmp5 = einsum(v.oovv, (0, 1, 2, 3), r2, (4, 1, 2, 3), (4, 0)) + tmp31 = einsum(r1, (0, 1), ints.tmp7, (2, 0, 3, 1), (2, 3)) + tmp19 = einsum(tmp0, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + tmp18 = einsum(v.ovvv, (0, 1, 2, 3), r2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp43 = einsum(tmp39, (0, 1, 2, 3), r1, (4, 3), (0, 1, 4, 2)) + tmp42 = einsum(ints.tmp7, (0, 1, 2, 3), r2, (4, 1, 5, 3), (0, 2, 4, 5)) + tmp41 = einsum(r2, (0, 1, 2, 3), v.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) + tmp57 = ints.tmp23.copy() + tmp57 += ints.tmp30.transpose((2, 0, 1, 3)) + tmp62 = ints.tmp55.copy() + tmp62 += ints.tmp71 * 2 + tmp62 += ints.tmp81 * -1 + tmp60 = ints.tmp10.copy() * 0.5 + tmp60 += ints.tmp4 + tmp26 = einsum(tmp25, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + del tmp25 + tmp23 = einsum(v.ooov, (0, 1, 2, 3), r1, (1, 3), (0, 2)) + tmp8 = f.oo.copy() + tmp8 += ints.tmp0 + tmp8 += ints.tmp12.transpose((1, 0)) + tmp8 += ints.tmp2 + tmp8 += ints.tmp9.transpose((1, 0)) * 0.5 + tmp28 = ints.tmp51.copy() + tmp28 += ints.tmp77 * -1 + tmp32 = tmp31.copy() + del tmp31 + tmp32 += tmp5 * 0.5 + tmp32 += tmp6.transpose((1, 0)) + tmp20 = tmp18.transpose((1, 0, 2, 3)).copy() + del tmp18 + tmp20 += tmp19 * -2 + del tmp19 + tmp16 = einsum(tmp2, (0, 1), r2, (2, 3, 4, 1), (0, 2, 3, 4)) * -1 + tmp14 = einsum(v.oovv, (0, 1, 2, 3), r2, (0, 1, 4, 3), (4, 2)) + tmp49 = einsum(r1, (0, 1), ints.tmp7, (2, 3, 4, 1), (2, 3, 4, 0)) + tmp10 = einsum(v.ovvv, (0, 1, 2, 3), r1, (0, 3), (1, 2)) + tmp44 = tmp41.copy() del tmp41 - tmp42 += tmp6 * 0.5 - tmp42 += tmp7.transpose((1, 0)) - tmp33 = einsum(v.ooov, (0, 1, 2, 3), r1, (1, 3), (0, 2)) - tmp38 = ints.tmp51.copy() - tmp38 += ints.tmp77 * -1 - tmp36 = einsum(tmp35, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) - del tmp35 - tmp45 = einsum(ints.tmp7, (0, 1, 2, 3), r1, (4, 3), (0, 1, 2, 4)) - tmp11 = einsum(r1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) - tmp18 = tmp15.copy() - del tmp15 - tmp18 += tmp16 * -1 - del tmp16 - tmp18 += tmp17 - del tmp17 - tmp20 = ints.tmp33.copy() - tmp20 += ints.tmp49 - tmp61 = ints.tmp23.copy() - tmp61 += ints.tmp30.transpose((2, 0, 1, 3)) - tmp26 = einsum(tmp2, (0, 1), r2, (2, 3, 4, 1), (0, 2, 3, 4)) * -1 - del tmp2 - tmp24 = einsum(r2, (0, 1, 2, 3), v.oovv, (0, 1, 4, 3), (2, 4)) - tmp30 = tmp28.transpose((1, 0, 2, 3)).copy() - del tmp28 - tmp30 += tmp29 * -2 - del tmp29 - tmp52 = ints.tmp10.copy() * 0.5 - tmp52 += ints.tmp4 - tmp54 = ints.tmp55.copy() - tmp54 += ints.tmp71 * 2 - tmp54 += ints.tmp81 * -1 - tmp49 = einsum(r1, (0, 1), v.ovvv, (0, 2, 3, 1), (2, 3)) - tmp40 = einsum(r2, (0, 1, 2, 3), tmp5, (1, 4), (4, 0, 2, 3)) * -1 - del tmp5 - tmp43 = einsum(t2, (0, 1, 2, 3), tmp42, (4, 1), (4, 0, 2, 3)) * -1 + tmp44 += tmp42 * -1 del tmp42 - tmp34 = einsum(t2, (0, 1, 2, 3), tmp33, (1, 4), (0, 4, 2, 3)) * -1 - del tmp33 - tmp39 = einsum(tmp38, (0, 1, 2, 3), r1, (4, 3), (0, 4, 1, 2)) * 0.5 - del tmp38 - tmp37 = einsum(t1, (0, 1), tmp36, (2, 0, 3, 4), (2, 3, 4, 1)) * -1 - del tmp36 - tmp64 = einsum(ints.tmp37, (0, 1, 2, 3), r1, (4, 3), (0, 4, 1, 2)) - tmp65 = einsum(r1, (0, 1), v.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) - tmp46 = einsum(tmp45, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) - del tmp45 - tmp10 = einsum(v.ovov, (0, 1, 2, 3), r2, (4, 2, 5, 1), (4, 0, 5, 3)) - tmp9 = einsum(ints.tmp57, (0, 1, 2, 3), r1, (4, 3), (0, 4, 1, 2)) - tmp12 = einsum(t1, (0, 1), tmp11, (2, 0, 3, 4), (2, 3, 1, 4)) - del tmp11 - tmp19 = einsum(tmp18, (0, 1, 2, 3), t1, (1, 4), (0, 2, 3, 4)) - del tmp18 - tmp21 = einsum(tmp20, (0, 1, 2, 3), r1, (1, 4), (0, 2, 3, 4)) - del tmp20 - tmp14 = einsum(tmp13, (0, 1, 2, 3), r2, (4, 1, 5, 3), (0, 4, 2, 5)) - del tmp13 - tmp62 = einsum(tmp61, (0, 1, 2, 3), r1, (0, 4), (1, 2, 3, 4)) - del tmp61 - tmp59 = einsum(v.ooov, (0, 1, 2, 3), r1, (2, 4), (0, 1, 4, 3)) - tmp60 = einsum(r2, (0, 1, 2, 3), f.vv, (4, 3), (0, 1, 4, 2)) - tmp23 = einsum(ints.tmp106, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) - tmp27 = einsum(t1, (0, 1), tmp26, (0, 2, 3, 4), (3, 2, 4, 1)) + tmp44 += tmp43 + del tmp43 + tmp37 = einsum(r1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp46 = ints.tmp33.copy() + tmp46 += ints.tmp49 + tmp58 = einsum(tmp57, (0, 1, 2, 3), r1, (0, 4), (1, 2, 3, 4)) + del tmp57 + tmp56 = einsum(r2, (0, 1, 2, 3), f.vv, (4, 3), (0, 1, 4, 2)) + tmp55 = einsum(r1, (0, 1), v.ooov, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp63 = einsum(tmp62, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) * 0.5 + del tmp62 + tmp61 = einsum(tmp60, (0, 1), r2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + del tmp60 + tmp27 = einsum(t1, (0, 1), tmp26, (2, 0, 3, 4), (2, 3, 4, 1)) * -1 del tmp26 - tmp25 = einsum(t2, (0, 1, 2, 3), tmp24, (4, 3), (0, 1, 4, 2)) * -1 - del tmp24 - tmp31 = einsum(t1, (0, 1), tmp30, (2, 3, 0, 4), (2, 3, 4, 1)) * 0.5 - del tmp30 - tmp53 = einsum(tmp52, (0, 1), r2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 - del tmp52 - tmp55 = einsum(tmp54, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) * 0.5 - del tmp54 - tmp57 = ints.tmp75.copy() - tmp57 += ints.tmp88.transpose((0, 2, 1, 3)) - tmp48 = einsum(ints.tmp94, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) - tmp50 = einsum(tmp49, (0, 1), t2, (2, 3, 4, 1), (2, 3, 4, 0)) * -1 + tmp24 = einsum(t2, (0, 1, 2, 3), tmp23, (1, 4), (0, 4, 2, 3)) * -1 + del tmp23 + tmp30 = einsum(r2, (0, 1, 2, 3), tmp8, (1, 4), (4, 0, 2, 3)) * -1 + tmp29 = einsum(tmp28, (0, 1, 2, 3), r1, (4, 3), (0, 4, 1, 2)) * 0.5 + del tmp28 + tmp33 = einsum(tmp32, (0, 1), t2, (2, 1, 3, 4), (0, 2, 3, 4)) * -1 + del tmp32 + tmp13 = einsum(ints.tmp106, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) + tmp21 = einsum(tmp20, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) * 0.5 + del tmp20 + tmp17 = einsum(tmp16, (0, 1, 2, 3), t1, (0, 4), (2, 1, 3, 4)) + del tmp16 + tmp15 = einsum(t2, (0, 1, 2, 3), tmp14, (4, 3), (0, 1, 4, 2)) * -1 + del tmp14 + tmp65 = ints.tmp75.copy() + tmp65 += ints.tmp88.transpose((0, 2, 1, 3)) + tmp52 = einsum(ints.tmp37, (0, 1, 2, 3), r1, (4, 3), (0, 4, 1, 2)) + tmp53 = einsum(v.ovvv, (0, 1, 2, 3), r1, (4, 1), (4, 0, 2, 3)) + tmp50 = einsum(t1, (0, 1), tmp49, (2, 3, 0, 4), (2, 3, 4, 1)) del tmp49 - tmp1 = ints.tmp7.copy() - tmp1 += v.ovoo.transpose((0, 2, 3, 1)) * -1 - r1new += einsum(tmp1, (0, 1, 2, 3), r2, (1, 2, 4, 3), (0, 4)) * 0.5 - tmp68 = einsum(r2, (0, 1, 2, 3), v.oovv, (4, 5, 2, 3), (0, 1, 4, 5)) - tmp44 = tmp34.transpose((0, 1, 3, 2)).copy() * -1 - del tmp34 - tmp44 += tmp37.transpose((0, 1, 3, 2)) - del tmp37 - tmp44 += tmp39.transpose((0, 1, 3, 2)) * -1 - del tmp39 - tmp44 += tmp40.transpose((0, 1, 3, 2)) - del tmp40 - tmp44 += tmp43.transpose((0, 1, 3, 2)) - del tmp43 - r2new = tmp44.transpose((1, 0, 2, 3)).copy() * -1 - r2new += tmp44 + tmp9 = einsum(r1, (0, 1), ints.tmp94, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp11 = einsum(t2, (0, 1, 2, 3), tmp10, (4, 3), (0, 1, 2, 4)) * -1 + del tmp10 + tmp45 = einsum(tmp44, (0, 1, 2, 3), t1, (1, 4), (0, 2, 3, 4)) del tmp44 - tmp66 = tmp64.copy() - del tmp64 - tmp66 += tmp65.transpose((0, 1, 3, 2)) * -1 - del tmp65 - r2new += tmp66.transpose((1, 0, 3, 2)) * -1 - r2new += tmp66.transpose((0, 1, 3, 2)) - del tmp66 - tmp47 = einsum(t1, (0, 1), tmp46, (2, 0, 3, 4), (2, 3, 1, 4)) + tmp36 = einsum(v.ovov, (0, 1, 2, 3), r2, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp38 = einsum(t1, (0, 1), tmp37, (2, 0, 3, 4), (2, 3, 1, 4)) + del tmp37 + tmp47 = einsum(tmp46, (0, 1, 2, 3), r1, (1, 4), (0, 2, 3, 4)) del tmp46 - r2new += tmp47.transpose((1, 0, 2, 3)) - r2new += tmp47 * -1 - del tmp47 - tmp22 = tmp9.copy() - del tmp9 - tmp22 += tmp10 - del tmp10 - tmp22 += tmp12 * -1 - del tmp12 - tmp22 += tmp14 * -1 - del tmp14 - tmp22 += tmp19 - del tmp19 - tmp22 += tmp21 - del tmp21 - r2new += tmp22.transpose((1, 0, 3, 2)) * -1 - r2new += tmp22.transpose((1, 0, 2, 3)) - r2new += tmp22.transpose((0, 1, 3, 2)) - r2new += tmp22 * -1 - del tmp22 + tmp35 = einsum(r1, (0, 1), ints.tmp57, (2, 3, 4, 1), (2, 0, 3, 4)) + tmp40 = einsum(r2, (0, 1, 2, 3), tmp39, (4, 1, 5, 3), (4, 0, 5, 2)) + del tmp39 + tmp1 = ints.tmp7.copy() + tmp1 += v.ovoo.transpose((0, 2, 3, 1)) * -1 + tmp67 = ints.tmp101.copy() + tmp67 += ints.tmp62 * 0.5 + tmp67 += v.oooo + tmp67 += ints.tmp40.transpose((0, 3, 1, 2)) * -1 + tmp67 += ints.tmp40.transpose((3, 0, 1, 2)) + tmp59 = tmp55.transpose((1, 0, 2, 3)).copy() * -1 + del tmp55 + tmp59 += tmp56.transpose((1, 0, 2, 3)) * -1 + del tmp56 + tmp59 += tmp58 + del tmp58 tmp71 = ints.tmp105.copy() * 2 tmp71 += ints.tmp17 * 2 tmp71 += ints.tmp26 * 2 @@ -1476,56 +1433,40 @@ def hbar_matvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp71 += ints.tmp18 * -2 tmp71 += ints.tmp22 * -2 tmp71 += ints.tmp70 * -2 - r2new += einsum(r1, (0, 1), tmp71, (2, 3), (0, 2, 3, 1)) * 0.5 - del tmp71 - tmp63 = tmp59.transpose((1, 0, 2, 3)).copy() * -1 - del tmp59 - tmp63 += tmp60.transpose((1, 0, 2, 3)) * -1 - del tmp60 - tmp63 += tmp62 - del tmp62 - r2new += tmp63.transpose((1, 0, 3, 2)) * -1 - r2new += tmp63.transpose((1, 0, 2, 3)) + tmp64 = tmp61.transpose((1, 0, 2, 3)).copy() * -1 + del tmp61 + tmp64 += tmp63 * -1 del tmp63 - tmp32 = tmp23.copy() - del tmp23 - tmp32 += tmp25 * 0.5 - del tmp25 - tmp32 += tmp27.transpose((1, 0, 2, 3)) * -1 + tmp34 = tmp24.transpose((0, 1, 3, 2)).copy() * -1 + del tmp24 + tmp34 += tmp27.transpose((0, 1, 3, 2)) del tmp27 - tmp32 += tmp31.transpose((1, 0, 3, 2)) - del tmp31 - r2new += tmp32.transpose((0, 1, 3, 2)) - r2new += tmp32 * -1 - del tmp32 - tmp56 = tmp53.transpose((1, 0, 2, 3)).copy() * -1 + tmp34 += tmp29.transpose((0, 1, 3, 2)) * -1 + del tmp29 + tmp34 += tmp30.transpose((0, 1, 3, 2)) + del tmp30 + tmp34 += tmp33.transpose((0, 1, 3, 2)) + del tmp33 + tmp22 = tmp13.copy() + del tmp13 + tmp22 += tmp15 * 0.5 + del tmp15 + tmp22 += tmp17.transpose((1, 0, 2, 3)) * -1 + del tmp17 + tmp22 += tmp21.transpose((1, 0, 3, 2)) + del tmp21 + tmp66 = einsum(tmp65, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) + del tmp65 + tmp54 = tmp52.copy() + del tmp52 + tmp54 += tmp53.transpose((0, 1, 3, 2)) * -1 del tmp53 - tmp56 += tmp55 * -1 - del tmp55 - r2new += tmp56.transpose((1, 0, 3, 2)) * -1 - r2new += tmp56.transpose((1, 0, 2, 3)) - del tmp56 - tmp58 = einsum(tmp57, (0, 1, 2, 3), r1, (2, 4), (0, 1, 3, 4)) - del tmp57 - r2new += tmp58.transpose((1, 0, 3, 2)) - r2new += tmp58.transpose((1, 0, 2, 3)) * -1 - r2new += tmp58.transpose((0, 1, 3, 2)) * -1 - r2new += tmp58 - del tmp58 - tmp51 = tmp48.copy() - del tmp48 - tmp51 += tmp50 + tmp51 = einsum(t1, (0, 1), tmp50, (2, 0, 3, 4), (2, 3, 1, 4)) del tmp50 - r2new += tmp51.transpose((0, 1, 3, 2)) * -1 - r2new += tmp51 - del tmp51 - tmp67 = ints.tmp101.copy() - tmp67 += v.oooo - tmp67 += ints.tmp62.transpose((0, 1, 3, 2)) * -0.5 - tmp67 += ints.tmp40.transpose((0, 3, 1, 2)) * -1 - tmp67 += ints.tmp40.transpose((3, 0, 1, 2)) - r2new += einsum(r2, (0, 1, 2, 3), tmp67, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 - del tmp67 + tmp12 = tmp9.copy() + del tmp9 + tmp12 += tmp11 + del tmp11 tmp70 = ints.tmp105.copy() tmp70 += ints.tmp17 tmp70 += ints.tmp26 @@ -1540,33 +1481,810 @@ def hbar_matvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) tmp70 += ints.tmp18 * -1 tmp70 += ints.tmp22 * -1 tmp70 += ints.tmp70 * -1 - r2new += einsum(tmp70, (0, 1), r1, (2, 3), (0, 2, 3, 1)) - r2new += einsum(r1, (0, 1), tmp70, (2, 3), (0, 2, 1, 3)) * -1 - r2new += einsum(tmp70, (0, 1), r1, (2, 3), (0, 2, 1, 3)) * -1 - del tmp70 + tmp68 = einsum(v.oovv, (0, 1, 2, 3), r2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp48 = tmp35.copy() + del tmp35 + tmp48 += tmp36 + del tmp36 + tmp48 += tmp38 * -1 + del tmp38 + tmp48 += tmp40 * -1 + del tmp40 + tmp48 += tmp45 + del tmp45 + tmp48 += tmp47 + del tmp47 tmp69 = t2.copy() - tmp69 += einsum(t1, (0, 1), t1, (2, 3), (2, 0, 3, 1)) * 2 - r2new += einsum(tmp69, (0, 1, 2, 3), tmp68, (4, 5, 0, 1), (5, 4, 3, 2)) * 0.25 - del tmp69, tmp68 + tmp69 += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) * 2 + tmp3 = ints.tmp5.copy() + tmp3 += v.ovov.transpose((0, 2, 3, 1)) * -1 tmp4 = ints.tmp10.transpose((1, 0)).copy() * 0.5 tmp4 += ints.tmp4.transpose((1, 0)) tmp4 += f.vv * -1 - r1new += einsum(r1, (0, 1), tmp4, (1, 2), (0, 2)) * -1 - del tmp4 - tmp3 = ints.tmp5.copy() - tmp3 += v.ovov.transpose((0, 2, 3, 1)) * -1 - r1new += einsum(tmp3, (0, 1, 2, 3), r1, (1, 3), (0, 2)) - del tmp3 - tmp8 = tmp6.transpose((1, 0)).copy() * 0.5 + tmp7 = tmp5.transpose((1, 0)).copy() * 0.5 + del tmp5 + tmp7 += einsum(tmp1, (0, 1, 2, 3), r1, (1, 3), (2, 0)) + tmp7 += tmp6 del tmp6 - tmp8 += einsum(tmp1, (0, 1, 2, 3), r1, (1, 3), (2, 0)) + r2new = einsum(r2, (0, 1, 2, 3), v.vvvv, (4, 5, 2, 3), (0, 1, 4, 5)) * 0.5 + r2new += tmp12 + r2new += tmp12.transpose((0, 1, 3, 2)) * -1 + del tmp12 + r2new += tmp22 * -1 + r2new += tmp22.transpose((0, 1, 3, 2)) + del tmp22 + r2new += tmp34 + r2new += tmp34.transpose((1, 0, 2, 3)) * -1 + del tmp34 + r2new += tmp48 * -1 + r2new += tmp48.transpose((0, 1, 3, 2)) + r2new += tmp48.transpose((1, 0, 2, 3)) + r2new += tmp48.transpose((1, 0, 3, 2)) * -1 + del tmp48 + r2new += tmp51 * -1 + r2new += tmp51.transpose((1, 0, 2, 3)) + del tmp51 + r2new += tmp54.transpose((0, 1, 3, 2)) + r2new += tmp54.transpose((1, 0, 3, 2)) * -1 + del tmp54 + r2new += tmp59.transpose((1, 0, 2, 3)) + r2new += tmp59.transpose((1, 0, 3, 2)) * -1 + del tmp59 + r2new += tmp64.transpose((1, 0, 2, 3)) + r2new += tmp64.transpose((1, 0, 3, 2)) * -1 + del tmp64 + r2new += tmp66 + r2new += tmp66.transpose((0, 1, 3, 2)) * -1 + r2new += tmp66.transpose((1, 0, 2, 3)) * -1 + r2new += tmp66.transpose((1, 0, 3, 2)) + del tmp66 + r2new += einsum(r2, (0, 1, 2, 3), tmp67, (4, 5, 0, 1), (4, 5, 2, 3)) * 0.5 + del tmp67 + r2new += einsum(tmp68, (0, 1, 2, 3), tmp69, (2, 3, 4, 5), (1, 0, 5, 4)) * 0.25 + del tmp68, tmp69 + r2new += einsum(tmp70, (0, 1), r1, (2, 3), (0, 2, 1, 3)) * -1 + r2new += einsum(tmp70, (0, 1), r1, (2, 3), (2, 0, 3, 1)) * -1 + r2new += einsum(r1, (0, 1), tmp71, (2, 3), (0, 2, 3, 1)) * 0.5 + del tmp71 + r2new += einsum(tmp70, (0, 1), r1, (2, 3), (0, 2, 3, 1)) + del tmp70 + r1new = einsum(tmp0, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + del tmp0 + r1new += einsum(v.ovvv, (0, 1, 2, 3), r2, (4, 0, 2, 3), (4, 1)) * -0.5 + r1new += einsum(r2, (0, 1, 2, 3), tmp1, (4, 0, 1, 3), (4, 2)) * 0.5 del tmp1 - tmp8 += tmp7 + r1new += einsum(tmp2, (0, 1), r2, (2, 0, 3, 1), (2, 3)) + del tmp2 + r1new += einsum(tmp3, (0, 1, 2, 3), r1, (1, 3), (0, 2)) + del tmp3 + r1new += einsum(r1, (0, 1), tmp4, (1, 2), (0, 2)) * -1 + del tmp4 + r1new += einsum(t1, (0, 1), tmp7, (0, 2), (2, 1)) * -1 del tmp7 - r1new += einsum(t1, (0, 1), tmp8, (0, 2), (2, 1)) * -1 + r1new += einsum(r1, (0, 1), tmp8, (0, 2), (2, 1)) * -1 del tmp8 - r1new += einsum(v.ovvv, (0, 1, 2, 3), r2, (4, 0, 2, 3), (4, 1)) * -0.5 - r2new += einsum(v.vvvv, (0, 1, 2, 3), r2, (4, 5, 2, 3), (4, 5, 0, 1)) * 0.5 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ip_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:02.729337. + + Parameters + ---------- + f : array + Fock matrix. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + tmp0 : array + tmp1 : array + tmp10 : array + tmp11 : array + tmp12 : array + tmp13 : array + tmp14 : array + tmp15 : array + tmp16 : array + tmp17 : array + tmp18 : array + tmp19 : array + tmp2 : array + tmp20 : array + tmp21 : array + tmp22 : array + tmp23 : array + tmp24 : array + tmp25 : array + tmp26 : array + tmp27 : array + tmp28 : array + tmp29 : array + tmp3 : array + tmp30 : array + tmp31 : array + tmp32 : array + tmp33 : array + tmp34 : array + tmp4 : array + tmp43 : array + tmp44 : array + tmp5 : array + tmp6 : array + tmp7 : array + tmp8 : array + tmp9 : array + """ + + tmp18 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp15 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp33 = einsum(t1, (0, 1), tmp18, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp24 = einsum(t1, (0, 1), tmp15, (2, 1), (0, 2)) + tmp30 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp28 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) + tmp26 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp6 = einsum(v.ooov, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp22 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp10 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) + tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp44 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp43 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp34 = einsum(t1, (0, 1), tmp33, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp32 = einsum(tmp24, (0, 1), t1, (1, 2), (0, 2)) + tmp31 = einsum(t1, (0, 1), tmp30, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp29 = einsum(tmp28, (0, 1), t1, (2, 1), (2, 0)) + tmp27 = einsum(tmp26, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + tmp25 = einsum(tmp6, (0, 1), t1, (0, 2), (1, 2)) + tmp23 = einsum(tmp22, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp21 = einsum(t1, (0, 1), tmp10, (2, 0), (2, 1)) + tmp20 = einsum(t2, (0, 1, 2, 3), tmp18, (4, 5, 1, 3), (4, 0, 5, 2)) * -1 + tmp19 = einsum(tmp18, (0, 1, 2, 3), t2, (2, 1, 4, 3), (0, 4)) + tmp17 = einsum(tmp15, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + tmp16 = einsum(tmp15, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp14 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp13 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) + tmp12 = einsum(v.ooov, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp11 = einsum(v.ovoo, (0, 1, 2, 3), t2, (2, 3, 4, 1), (0, 4)) + tmp9 = einsum(v.ovov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 2, 1)) + tmp8 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp7 = einsum(v.oooo, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp5 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) + tmp4 = einsum(t2, (0, 1, 2, 3), f.ov, (4, 3), (4, 0, 1, 2)) + tmp3 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp2 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp1 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + + return {f"tmp0": tmp0, f"tmp1": tmp1, f"tmp10": tmp10, f"tmp11": tmp11, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp14": tmp14, f"tmp15": tmp15, f"tmp16": tmp16, f"tmp17": tmp17, f"tmp18": tmp18, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp21": tmp21, f"tmp22": tmp22, f"tmp23": tmp23, f"tmp24": tmp24, f"tmp25": tmp25, f"tmp26": tmp26, f"tmp27": tmp27, f"tmp28": tmp28, f"tmp29": tmp29, f"tmp3": tmp3, f"tmp30": tmp30, f"tmp31": tmp31, f"tmp32": tmp32, f"tmp33": tmp33, f"tmp34": tmp34, f"tmp4": tmp4, f"tmp43": tmp43, f"tmp44": tmp44, f"tmp5": tmp5, f"tmp6": tmp6, f"tmp7": tmp7, f"tmp8": tmp8, f"tmp9": tmp9} + +def hbar_lmatvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:02.745023. + + Parameters + ---------- + f : array + Fock matrix. + r1 : array + R1 amplitudes. + r2 : array + R2 amplitudes. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + r1new : array + Updated R1 residuals. + r2new : array + Updated R2 residuals. + """ + + ints = kwargs["ints"] + tmp9 = ints.tmp30.copy() + tmp9 += ints.tmp44 + tmp6 = einsum(t1, (0, 1), r2, (2, 3, 1), (2, 3, 0)) + tmp13 = f.oo.copy() + tmp13 += ints.tmp0.transpose((1, 0)) + tmp13 += ints.tmp24 + tmp13 += ints.tmp6.transpose((1, 0)) + tmp10 = einsum(tmp9, (0, 1, 2, 3), r2, (4, 0, 2), (1, 4, 3)) * -1 + del tmp9 + tmp8 = einsum(v.ooov, (0, 1, 2, 3), tmp6, (4, 2, 1), (4, 0, 3)) + tmp4 = einsum(r2, (0, 1, 2), ints.tmp10, (1, 3), (3, 0, 2)) + tmp5 = einsum(r2, (0, 1, 2), v.ovov, (3, 2, 1, 4), (0, 3, 4)) + tmp7 = einsum(tmp6, (0, 1, 2), ints.tmp18, (1, 3, 2, 4), (3, 0, 4)) + del tmp6 + tmp11 = f.ov.copy() + tmp11 += ints.tmp15 + tmp17 = ints.tmp18.copy() + tmp17 += v.ovoo.transpose((0, 2, 3, 1)) * -1 + tmp15 = ints.tmp22.copy() + tmp15 += ints.tmp33 * 2 + tmp15 += v.oooo * 2 + tmp15 += ints.tmp26.transpose((0, 3, 1, 2)) * -4 + tmp3 = einsum(r2, (0, 1, 2), t2, (0, 1, 3, 2), (3,)) + tmp14 = einsum(r2, (0, 1, 2), tmp13, (1, 3), (3, 0, 2)) * -1 + del tmp13 + tmp12 = tmp4.copy() * -0.5 + del tmp4 + tmp12 += tmp5 + del tmp5 + tmp12 += tmp7 * -1 + del tmp7 + tmp12 += tmp8 * -1 + del tmp8 + tmp12 += tmp10 * -1 + del tmp10 + tmp12 += einsum(r1, (0,), tmp11, (1, 2), (1, 0, 2)) + tmp16 = ints.tmp28.copy() + tmp16 += ints.tmp43 * 0.5 + tmp16 += f.vv * -1 + tmp16 += einsum(t1, (0, 1), tmp11, (0, 2), (1, 2)) + del tmp11 + tmp2 = f.oo.copy() * 2 + tmp2 += ints.tmp0.transpose((1, 0)) * 2 + tmp2 += ints.tmp10 + tmp2 += ints.tmp24 * 2 + tmp2 += ints.tmp6.transpose((1, 0)) * 2 + tmp0 = ints.tmp12.copy() + tmp0 += ints.tmp23.transpose((0, 2, 1, 3)) * 0.25 + tmp0 += ints.tmp34.transpose((0, 2, 1, 3)) * 0.5 + tmp0 += ints.tmp4.transpose((1, 0, 2, 3)) * 0.5 + tmp0 += ints.tmp7.transpose((0, 2, 1, 3)) * 0.5 + tmp0 += ints.tmp9 + tmp0 += ints.tmp14.transpose((0, 2, 1, 3)) * -0.25 + tmp0 += ints.tmp17.transpose((0, 2, 1, 3)) * -0.5 + tmp0 += ints.tmp20.transpose((0, 2, 1, 3)) * -1 + tmp0 += ints.tmp27 * -1 + tmp0 += ints.tmp31.transpose((0, 2, 1, 3)) * -0.5 + tmp0 += v.ooov.transpose((0, 2, 1, 3)) * -0.5 + tmp1 = ints.tmp11.copy() + tmp1 += ints.tmp13 + tmp1 += ints.tmp19 + tmp1 += ints.tmp1 * 2 + tmp1 += ints.tmp21 + tmp1 += ints.tmp25 * 2 + tmp1 += ints.tmp29 * 2 + tmp1 += ints.tmp32 * 2 + tmp1 += ints.tmp5 * 2 + tmp1 += ints.tmp8 * 2 + tmp1 += f.ov * -2 + tmp1 += ints.tmp16 * -2 + tmp1 += ints.tmp2 * -2 + tmp1 += ints.tmp3 * -2 + r2new = einsum(tmp3, (0,), v.oovv, (1, 2, 3, 0), (1, 2, 3)) * 0.5 + del tmp3 + r2new += tmp12 * -1 + r2new += tmp12.transpose((1, 0, 2)) + del tmp12 + r2new += tmp14 * -1 + r2new += tmp14.transpose((1, 0, 2)) + del tmp14 + r2new += einsum(r2, (0, 1, 2), tmp15, (0, 1, 3, 4), (3, 4, 2)) * 0.25 + del tmp15 + r2new += einsum(tmp16, (0, 1), r2, (2, 3, 0), (2, 3, 1)) * -1 + del tmp16 + r2new += einsum(tmp17, (0, 1, 2, 3), r1, (0,), (2, 1, 3)) * -1 + del tmp17 + r1new = einsum(r2, (0, 1, 2), tmp0, (1, 3, 0, 2), (3,)) * -1 + del tmp0 + r1new += einsum(tmp1, (0, 1), r2, (2, 0, 1), (2,)) * -0.5 + del tmp1 + r1new += einsum(r1, (0,), tmp2, (0, 1), (1,)) * -0.5 + del tmp2 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ea_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:09.386301. + + Parameters + ---------- + f : array + Fock matrix. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + tmp1 : array + tmp10 : array + tmp11 : array + tmp12 : array + tmp13 : array + tmp14 : array + tmp15 : array + tmp16 : array + tmp17 : array + tmp18 : array + tmp19 : array + tmp2 : array + tmp20 : array + tmp21 : array + tmp22 : array + tmp23 : array + tmp24 : array + tmp25 : array + tmp27 : array + tmp28 : array + tmp29 : array + tmp3 : array + tmp30 : array + tmp5 : array + tmp6 : array + tmp7 : array + tmp8 : array + """ + + tmp16 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp29 = einsum(t1, (0, 1), tmp16, (2, 1), (0, 2)) + tmp7 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) + tmp24 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 1), (2, 3)) + tmp21 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) + tmp18 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp5 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp30 = einsum(tmp29, (0, 1), t1, (1, 2), (0, 2)) + tmp28 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp27 = einsum(tmp7, (0, 1), t1, (2, 1), (2, 0)) + tmp25 = einsum(t1, (0, 1), tmp24, (0, 2), (2, 1)) + tmp23 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp22 = einsum(tmp21, (0, 1), t1, (1, 2), (0, 2)) + tmp20 = einsum(t2, (0, 1, 2, 3), tmp18, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 + tmp19 = einsum(tmp18, (0, 1, 2, 3), t2, (2, 1, 4, 3), (0, 4)) + tmp17 = einsum(tmp16, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp15 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp14 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) + tmp13 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) + tmp12 = einsum(v.ovoo, (0, 1, 2, 3), t2, (2, 3, 4, 1), (0, 4)) + tmp11 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp10 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp8 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp6 = einsum(tmp5, (0, 1), t1, (0, 2), (1, 2)) + tmp3 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp2 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp1 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + + return {f"tmp1": tmp1, f"tmp10": tmp10, f"tmp11": tmp11, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp14": tmp14, f"tmp15": tmp15, f"tmp16": tmp16, f"tmp17": tmp17, f"tmp18": tmp18, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp21": tmp21, f"tmp22": tmp22, f"tmp23": tmp23, f"tmp24": tmp24, f"tmp25": tmp25, f"tmp27": tmp27, f"tmp28": tmp28, f"tmp29": tmp29, f"tmp3": tmp3, f"tmp30": tmp30, f"tmp5": tmp5, f"tmp6": tmp6, f"tmp7": tmp7, f"tmp8": tmp8} + +def hbar_lmatvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:09.399012. + + Parameters + ---------- + f : array + Fock matrix. + r1 : array + R1 amplitudes. + r2 : array + R2 amplitudes. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + r1new : array + Updated R1 residuals. + r2new : array + Updated R2 residuals. + """ + + ints = kwargs["ints"] + tmp10 = f.ov.copy() + tmp10 += ints.tmp16 + tmp17 = einsum(t1, (0, 1), v.ooov, (2, 0, 3, 4), (2, 3, 1, 4)) + tmp11 = einsum(ints.tmp18, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + tmp14 = einsum(tmp10, (0, 1), t1, (0, 2), (1, 2)) * 2 + tmp18 = v.ovov.transpose((0, 2, 1, 3)).copy() + tmp18 += tmp17.transpose((1, 0, 3, 2)) * -1 + del tmp17 + tmp12 = ints.tmp23.copy() + tmp12 += ints.tmp28 + tmp12 += tmp11.transpose((0, 1, 3, 2)) * -1 + del tmp11 + tmp15 = ints.tmp11.copy() + tmp15 += f.vv * -2 + tmp15 += tmp14.transpose((1, 0)) + del tmp14 + tmp22 = t2.copy() + tmp22 += einsum(t1, (0, 1), t1, (2, 3), (0, 2, 1, 3)) * 2 + tmp7 = einsum(t1, (0, 1), r1, (1,), (0,)) + tmp8 = einsum(r2, (0, 1, 2), t2, (3, 2, 0, 1), (3,)) + tmp19 = einsum(tmp18, (0, 1, 2, 3), r2, (4, 3, 0), (1, 2, 4)) * -1 + del tmp18 + tmp13 = einsum(r2, (0, 1, 2), tmp12, (2, 3, 1, 4), (3, 4, 0)) * -1 + del tmp12 + tmp16 = einsum(r2, (0, 1, 2), tmp15, (1, 3), (2, 3, 0)) * -0.5 + del tmp15 + tmp1 = einsum(t1, (0, 1), r2, (2, 1, 3), (3, 0, 2)) + tmp24 = f.oo.copy() + tmp24 += ints.tmp21 * 0.5 + tmp24 += ints.tmp24.transpose((1, 0)) + tmp24 += ints.tmp29 + tmp24 += ints.tmp5.transpose((1, 0)) + tmp23 = einsum(tmp22, (0, 1, 2, 3), r2, (2, 3, 4), (4, 1, 0)) * -1 + del tmp22 + tmp9 = tmp7.copy() * 2 + del tmp7 + tmp9 += tmp8 + del tmp8 + tmp21 = einsum(r2, (0, 1, 2), ints.tmp7, (1, 3), (2, 3, 0)) + tmp20 = tmp13.copy() * -1 + del tmp13 + tmp20 += tmp16 + del tmp16 + tmp20 += tmp19.transpose((0, 2, 1)) * -1 + del tmp19 + tmp20 += einsum(tmp10, (0, 1), r1, (2,), (0, 1, 2)) + tmp2 = ints.tmp23.copy() + tmp2 += ints.tmp28 + tmp2 += v.ovov.transpose((0, 2, 3, 1)) * -1 + tmp0 = ints.tmp10.copy() * 0.5 + tmp0 += ints.tmp15 + tmp0 += ints.tmp20 * 0.25 + tmp0 += ints.tmp13 * -0.25 + tmp0 += v.ovvv.transpose((0, 2, 3, 1)) * -0.5 + tmp3 = einsum(t1, (0, 1), tmp1, (2, 3, 1), (2, 3, 0)) * -1 + tmp4 = ints.tmp18.copy() + tmp4 += v.ovoo.transpose((0, 2, 3, 1)) * -1 + tmp5 = ints.tmp12.copy() + tmp5 += ints.tmp14 + tmp5 += ints.tmp19 + tmp5 += ints.tmp1 * 2 + tmp5 += ints.tmp22 + tmp5 += ints.tmp25 * 2 + tmp5 += ints.tmp27 * 2 + tmp5 += ints.tmp30 * 2 + tmp5 += ints.tmp6 * 2 + tmp5 += ints.tmp8 * 2 + tmp5 += f.ov * -2 + tmp5 += ints.tmp17 * -2 + tmp5 += ints.tmp2 * -2 + tmp5 += ints.tmp3 * -2 + tmp6 = ints.tmp11.copy() * 0.5 + tmp6 += ints.tmp7 + tmp6 += f.vv * -1 + r2new = einsum(v.ovvv, (0, 1, 2, 3), r1, (1,), (2, 3, 0)) * -1 + r2new += einsum(tmp1, (0, 1, 2), v.ovvv, (1, 2, 3, 4), (3, 4, 0)) + r2new += einsum(v.vvvv, (0, 1, 2, 3), r2, (2, 3, 4), (0, 1, 4)) * 0.5 + r2new += tmp20.transpose((1, 2, 0)) * -1 + r2new += tmp20.transpose((2, 1, 0)) + del tmp20 + r2new += tmp21.transpose((1, 2, 0)) + r2new += tmp21.transpose((2, 1, 0)) * -1 + del tmp21 + r2new += einsum(tmp23, (0, 1, 2), v.oovv, (1, 2, 3, 4), (3, 4, 0)) * 0.25 + del tmp23 + r2new += einsum(r2, (0, 1, 2), tmp24, (2, 3), (0, 1, 3)) * -1 + del tmp24 + r2new += einsum(v.oovv, (0, 1, 2, 3), tmp9, (1,), (2, 3, 0)) * 0.5 + r1new = einsum(r2, (0, 1, 2), tmp0, (2, 0, 1, 3), (3,)) + del tmp0 + r1new += einsum(tmp1, (0, 1, 2), tmp2, (0, 1, 2, 3), (3,)) + del tmp1, tmp2 + r1new += einsum(tmp4, (0, 1, 2, 3), tmp3, (0, 2, 1), (3,)) * -0.5 + del tmp4, tmp3 + r1new += einsum(tmp5, (0, 1), r2, (2, 1, 0), (2,)) * -0.5 + del tmp5 + r1new += einsum(tmp6, (0, 1), r1, (0,), (1,)) * -1 + del tmp6 + r1new += einsum(tmp10, (0, 1), tmp9, (0,), (1,)) * -0.5 + del tmp10, tmp9 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ee_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:20.353163. + + Parameters + ---------- + f : array + Fock matrix. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + tmp0 : array + tmp10 : array + tmp11 : array + tmp12 : array + tmp13 : array + tmp15 : array + tmp16 : array + tmp17 : array + tmp19 : array + tmp2 : array + tmp20 : array + tmp21 : array + tmp22 : array + tmp23 : array + tmp24 : array + tmp26 : array + tmp27 : array + tmp28 : array + tmp29 : array + tmp3 : array + tmp30 : array + tmp31 : array + tmp32 : array + tmp33 : array + tmp34 : array + tmp35 : array + tmp36 : array + tmp38 : array + tmp39 : array + tmp4 : array + tmp40 : array + tmp41 : array + tmp43 : array + tmp44 : array + tmp45 : array + tmp46 : array + tmp47 : array + tmp5 : array + tmp7 : array + tmp8 : array + tmp9 : array + """ + + tmp29 = einsum(v.oovv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp26 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp46 = einsum(t1, (0, 1), tmp29, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp38 = einsum(t1, (0, 1), tmp26, (2, 1), (0, 2)) + tmp10 = einsum(t1, (0, 1), v.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp9 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 3), (1, 2)) + tmp40 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp8 = einsum(v.ooov, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp34 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp16 = einsum(t2, (0, 1, 2, 3), v.oovv, (4, 1, 2, 3), (0, 4)) + tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp47 = einsum(tmp46, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp45 = einsum(tmp38, (0, 1), t1, (1, 2), (0, 2)) + tmp44 = einsum(t1, (0, 1), tmp10, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp43 = einsum(t1, (0, 1), tmp9, (2, 1), (0, 2)) + tmp41 = einsum(tmp40, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + tmp39 = einsum(tmp8, (0, 1), t1, (0, 2), (1, 2)) + tmp36 = einsum(v.oovv, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp35 = einsum(tmp34, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp33 = einsum(tmp16, (0, 1), t1, (1, 2), (0, 2)) + tmp32 = einsum(t2, (0, 1, 2, 3), tmp29, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 + tmp31 = einsum(t2, (0, 1, 2, 3), tmp29, (4, 5, 1, 3), (4, 0, 5, 2)) * -1 + tmp30 = einsum(t2, (0, 1, 2, 3), tmp29, (4, 1, 0, 3), (4, 2)) + tmp28 = einsum(tmp26, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) * -1 + tmp27 = einsum(tmp26, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp24 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp23 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp22 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 2, 3), (0, 4)) + tmp21 = einsum(t2, (0, 1, 2, 3), v.ovoo, (4, 5, 0, 1), (4, 2, 3, 5)) + tmp20 = einsum(v.ooov, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp19 = einsum(v.ovoo, (0, 1, 2, 3), t2, (2, 3, 4, 1), (0, 4)) + tmp17 = einsum(v.oovv, (0, 1, 2, 3), t2, (0, 1, 4, 3), (4, 2)) + tmp15 = einsum(v.vvvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp13 = einsum(v.ovov, (0, 1, 2, 3), t1, (4, 3), (4, 0, 2, 1)) + tmp12 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp11 = einsum(v.oooo, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp7 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) + tmp5 = einsum(t2, (0, 1, 2, 3), f.ov, (4, 3), (4, 0, 1, 2)) + tmp4 = einsum(f.ov, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp3 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp2 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + + return {f"tmp0": tmp0, f"tmp10": tmp10, f"tmp11": tmp11, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp15": tmp15, f"tmp16": tmp16, f"tmp17": tmp17, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp21": tmp21, f"tmp22": tmp22, f"tmp23": tmp23, f"tmp24": tmp24, f"tmp26": tmp26, f"tmp27": tmp27, f"tmp28": tmp28, f"tmp29": tmp29, f"tmp3": tmp3, f"tmp30": tmp30, f"tmp31": tmp31, f"tmp32": tmp32, f"tmp33": tmp33, f"tmp34": tmp34, f"tmp35": tmp35, f"tmp36": tmp36, f"tmp38": tmp38, f"tmp39": tmp39, f"tmp4": tmp4, f"tmp40": tmp40, f"tmp41": tmp41, f"tmp43": tmp43, f"tmp44": tmp44, f"tmp45": tmp45, f"tmp46": tmp46, f"tmp47": tmp47, f"tmp5": tmp5, f"tmp7": tmp7, f"tmp8": tmp8, f"tmp9": tmp9} + +def hbar_lmatvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:14:20.373234. + + Parameters + ---------- + f : array + Fock matrix. + r1 : array + R1 amplitudes. + r2 : array + R2 amplitudes. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + r1new : array + Updated R1 residuals. + r2new : array + Updated R2 residuals. + """ + + ints = kwargs["ints"] + tmp2 = einsum(r2, (0, 1, 2, 3), t2, (4, 1, 2, 3), (0, 4)) + tmp0 = einsum(t1, (0, 1), r1, (2, 1), (2, 0)) + tmp14 = f.oo.copy() + tmp14 += ints.tmp0.transpose((1, 0)) + tmp14 += ints.tmp16 * 0.5 + tmp14 += ints.tmp38 + tmp14 += ints.tmp8.transpose((1, 0)) + tmp12 = tmp0.copy() * 2 + tmp12 += tmp2 + tmp5 = einsum(t1, (0, 1), r2, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp16 = f.ov.copy() + tmp16 += ints.tmp26 + tmp1 = einsum(t2, (0, 1, 2, 3), r2, (0, 1, 4, 3), (4, 2)) + tmp26 = ints.tmp10.copy() + tmp26 += ints.tmp36 + tmp17 = einsum(tmp14, (0, 1), r2, (2, 0, 3, 4), (1, 2, 3, 4)) * -1 + tmp18 = einsum(tmp12, (0, 1), v.oovv, (2, 1, 3, 4), (2, 0, 3, 4)) * -0.5 + tmp21 = einsum(tmp16, (0, 1), tmp5, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp20 = einsum(v.oovv, (0, 1, 2, 3), tmp1, (4, 3), (0, 1, 4, 2)) * -1 + tmp27 = einsum(r2, (0, 1, 2, 3), tmp26, (1, 4, 3, 5), (4, 0, 5, 2)) + del tmp26 + tmp24 = einsum(v.ooov, (0, 1, 2, 3), tmp5, (4, 2, 1, 5), (4, 0, 5, 3)) + tmp23 = einsum(v.ovov, (0, 1, 2, 3), r2, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp25 = einsum(ints.tmp29, (0, 1, 2, 3), tmp5, (4, 0, 2, 5), (1, 4, 3, 5)) + tmp34 = ints.tmp17.copy() * 0.5 + tmp34 += ints.tmp9 + tmp32 = einsum(r2, (0, 1, 2, 3), f.vv, (4, 3), (0, 1, 4, 2)) + tmp31 = einsum(r1, (0, 1), v.ooov, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp30 = einsum(ints.tmp29, (0, 1, 2, 3), r1, (0, 4), (1, 2, 3, 4)) + tmp7 = einsum(t1, (0, 1), tmp5, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp36 = ints.tmp40.transpose((0, 3, 1, 2)).copy() + tmp36 += ints.tmp34 * -0.25 + tmp36 += ints.tmp46 * -0.5 + tmp36 += v.oooo * -0.5 + tmp19 = tmp17.transpose((0, 1, 3, 2)).copy() + del tmp17 + tmp19 += tmp18.transpose((1, 0, 3, 2)) + del tmp18 + tmp22 = tmp20.copy() * -0.5 + del tmp20 + tmp22 += tmp21.transpose((1, 0, 3, 2)) * -1 + del tmp21 + tmp28 = tmp23.copy() * -1 + del tmp23 + tmp28 += tmp24 + del tmp24 + tmp28 += tmp25 * -1 + del tmp25 + tmp28 += tmp27 + del tmp27 + tmp28 += einsum(tmp16, (0, 1), r1, (2, 3), (0, 2, 1, 3)) + tmp35 = einsum(r2, (0, 1, 2, 3), tmp34, (3, 4), (0, 1, 4, 2)) * -1 + del tmp34 + tmp29 = einsum(v.ovvv, (0, 1, 2, 3), r1, (4, 1), (4, 0, 2, 3)) + tmp33 = tmp30.copy() * -1 + del tmp30 + tmp33 += tmp31.transpose((1, 0, 2, 3)) + del tmp31 + tmp33 += tmp32.transpose((1, 0, 2, 3)) + del tmp32 + tmp37 = einsum(t2, (0, 1, 2, 3), r2, (4, 5, 2, 3), (4, 5, 0, 1)) * -0.5 + tmp37 += tmp7.transpose((0, 1, 3, 2)) + tmp3 = ints.tmp15.copy() * 0.5 + tmp3 += ints.tmp24 + tmp3 += ints.tmp32 * 0.25 + tmp3 += ints.tmp21 * -0.25 + tmp3 += v.ovvv.transpose((0, 2, 3, 1)) * -0.5 + tmp4 = ints.tmp11.copy() + tmp4 += ints.tmp13.transpose((0, 2, 1, 3)) * 2 + tmp4 += ints.tmp20.transpose((0, 2, 1, 3)) * 2 + tmp4 += ints.tmp35 * 0.5 + tmp4 += ints.tmp47 + tmp4 += ints.tmp5.transpose((1, 2, 0, 3)) + tmp4 += ints.tmp23 * -0.5 + tmp4 += ints.tmp28 * -1 + tmp4 += ints.tmp31 * -2 + tmp4 += ints.tmp41.transpose((0, 2, 1, 3)) * -2 + tmp4 += ints.tmp44 * -1 + tmp4 += v.ooov * -1 + tmp15 = tmp0.copy() + tmp15 += tmp2 * 0.5 + tmp10 = einsum(t2, (0, 1, 2, 3), r1, (1, 3), (0, 2)) * 2 + tmp10 += einsum(t2, (0, 1, 2, 3), tmp5, (1, 0, 4, 3), (4, 2)) * -1 + tmp9 = ints.tmp12.copy() + tmp9 += ints.tmp19 * 0.5 + tmp9 += ints.tmp22 * 0.5 + tmp9 += ints.tmp2 + tmp9 += ints.tmp30 * 0.5 + tmp9 += ints.tmp33 * 0.5 + tmp9 += ints.tmp39 + tmp9 += ints.tmp43 + tmp9 += ints.tmp45 + tmp9 += ints.tmp7 + tmp9 += f.ov * -1 + tmp9 += ints.tmp27 * -1 + tmp9 += ints.tmp3 * -1 + tmp9 += ints.tmp4 * -1 + tmp13 = ints.tmp17.copy() * 0.5 + tmp13 += ints.tmp9 + tmp13 += f.vv * -1 + tmp6 = ints.tmp10.copy() + tmp6 += ints.tmp36 + tmp6 += v.ovov.transpose((0, 2, 3, 1)) * -1 + tmp11 = ints.tmp10.copy() + tmp11 += v.ovov.transpose((0, 2, 3, 1)) * -1 + tmp8 = ints.tmp29.copy() + tmp8 += v.ovoo.transpose((0, 2, 3, 1)) * -1 + r2new = einsum(v.ovvv, (0, 1, 2, 3), tmp5, (4, 5, 0, 1), (5, 4, 2, 3)) * -1 + r2new += einsum(r2, (0, 1, 2, 3), v.vvvv, (4, 5, 2, 3), (0, 1, 4, 5)) * 0.5 + r2new += tmp19 + r2new += tmp19.transpose((1, 0, 2, 3)) * -1 + del tmp19 + r2new += tmp22 + r2new += tmp22.transpose((0, 1, 3, 2)) * -1 + del tmp22 + r2new += tmp28 + r2new += tmp28.transpose((0, 1, 3, 2)) * -1 + r2new += tmp28.transpose((1, 0, 2, 3)) * -1 + r2new += tmp28.transpose((1, 0, 3, 2)) + del tmp28 + r2new += tmp29.transpose((0, 1, 3, 2)) + r2new += tmp29.transpose((1, 0, 3, 2)) * -1 + del tmp29 + r2new += tmp33.transpose((1, 0, 2, 3)) * -1 + r2new += tmp33.transpose((1, 0, 3, 2)) + del tmp33 + r2new += tmp35.transpose((1, 0, 2, 3)) + r2new += tmp35.transpose((1, 0, 3, 2)) * -1 + del tmp35 + r2new += einsum(r2, (0, 1, 2, 3), tmp36, (0, 1, 4, 5), (4, 5, 2, 3)) * -1 + del tmp36 + r2new += einsum(v.oovv, (0, 1, 2, 3), tmp37, (4, 5, 0, 1), (5, 4, 2, 3)) * 0.5 + del tmp37 + r1new = einsum(ints.tmp29, (0, 1, 2, 3), tmp0, (0, 2), (1, 3)) * -1 + del tmp0 + r1new += einsum(tmp1, (0, 1), v.ovvv, (2, 0, 3, 1), (2, 3)) * 0.5 + del tmp1 + r1new += einsum(ints.tmp29, (0, 1, 2, 3), tmp2, (0, 2), (1, 3)) * -0.5 + del tmp2 + r1new += einsum(tmp3, (0, 1, 2, 3), r2, (4, 0, 1, 2), (4, 3)) + del tmp3 + r1new += einsum(r2, (0, 1, 2, 3), tmp4, (0, 1, 4, 3), (4, 2)) * 0.5 + del tmp4 + r1new += einsum(tmp5, (0, 1, 2, 3), tmp6, (0, 2, 3, 4), (1, 4)) * -1 + del tmp5, tmp6 + r1new += einsum(tmp8, (0, 1, 2, 3), tmp7, (4, 0, 2, 1), (4, 3)) * -0.5 + del tmp7, tmp8 + r1new += einsum(r2, (0, 1, 2, 3), tmp9, (1, 3), (0, 2)) * -1 + del tmp9 + r1new += einsum(v.oovv, (0, 1, 2, 3), tmp10, (1, 3), (0, 2)) * 0.5 + del tmp10 + r1new += einsum(tmp11, (0, 1, 2, 3), r1, (0, 2), (1, 3)) + del tmp11 + r1new += einsum(v.ooov, (0, 1, 2, 3), tmp12, (2, 1), (0, 3)) * 0.5 + del tmp12 + r1new += einsum(r1, (0, 1), tmp13, (1, 2), (0, 2)) * -1 + del tmp13 + r1new += einsum(tmp14, (0, 1), r1, (0, 2), (1, 2)) * -1 + del tmp14 + r1new += einsum(tmp15, (0, 1), tmp16, (1, 2), (0, 2)) * -1 + del tmp16, tmp15 return {f"r1new": r1new, f"r2new": r2new} diff --git a/ebcc/codegen/RCCSD.py b/ebcc/codegen/RCCSD.py index 51b338ea..e5725f96 100644 --- a/ebcc/codegen/RCCSD.py +++ b/ebcc/codegen/RCCSD.py @@ -2018,3 +2018,634 @@ def hbar_matvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) return {f"r1new": r1new, f"r2new": r2new} +def hbar_lmatvec_ip_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:21:23.772354. + + Parameters + ---------- + f : array + Fock matrix. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + tmp0 : array + tmp1 : array + tmp100 : array + tmp103 : array + tmp104 : array + tmp107 : array + tmp108 : array + tmp112 : array + tmp113 : array + tmp114 : array + tmp116 : array + tmp117 : array + tmp12 : array + tmp13 : array + tmp134 : array + tmp136 : array + tmp14 : array + tmp17 : array + tmp19 : array + tmp2 : array + tmp20 : array + tmp21 : array + tmp22 : array + tmp24 : array + tmp26 : array + tmp29 : array + tmp3 : array + tmp32 : array + tmp33 : array + tmp35 : array + tmp36 : array + tmp38 : array + tmp4 : array + tmp41 : array + tmp44 : array + tmp47 : array + tmp48 : array + tmp49 : array + tmp51 : array + tmp54 : array + tmp57 : array + tmp6 : array + tmp60 : array + tmp63 : array + tmp66 : array + tmp69 : array + tmp70 : array + tmp72 : array + tmp73 : array + tmp75 : array + tmp78 : array + tmp81 : array + tmp82 : array + tmp85 : array + tmp86 : array + tmp87 : array + tmp88 : array + tmp9 : array + tmp90 : array + tmp91 : array + tmp92 : array + tmp93 : array + tmp94 : array + tmp97 : array + tmp98 : array + tmp99 : array + """ + + tmp20 = einsum(t1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp17 = einsum(v.ovov, (0, 1, 2, 3), t1, (2, 3), (0, 1)) + tmp47 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp107 = einsum(t1, (0, 1), tmp20, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp86 = einsum(t1, (0, 1), tmp17, (2, 1), (0, 2)) + tmp85 = einsum(t1, (0, 1), tmp47, (2, 1), (0, 2)) + tmp99 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp97 = einsum(t1, (0, 1), v.ovvv, (0, 2, 3, 1), (2, 3)) + tmp93 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 1), (2, 3)) + tmp90 = einsum(t1, (0, 1), v.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp13 = einsum(v.ooov, (0, 1, 2, 3), t1, (2, 3), (0, 1)) + tmp12 = einsum(v.ooov, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp81 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp22 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 3, 1), (4, 0)) + tmp24 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 1, 3), (4, 0)) + tmp0 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp136 = einsum(t2, (0, 1, 2, 3), v.ovov, (0, 2, 1, 4), (3, 4)) + tmp134 = einsum(t2, (0, 1, 2, 3), v.ovov, (0, 4, 1, 2), (3, 4)) + tmp117 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 5, 1, 3), (0, 4, 2, 5)) + tmp116 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 5, 1, 2), (0, 4, 3, 5)) + tmp114 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp113 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 2, 1, 5), (0, 4, 3, 5)) + tmp112 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 1), (4, 0, 2, 3)) + tmp108 = einsum(t1, (0, 1), tmp107, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp104 = einsum(t1, (0, 1), tmp86, (2, 0), (2, 1)) + tmp103 = einsum(t1, (0, 1), tmp85, (2, 0), (2, 1)) + tmp100 = einsum(tmp99, (0, 1, 2, 3), t1, (4, 2), (4, 0, 1, 3)) + tmp98 = einsum(t1, (0, 1), tmp97, (1, 2), (0, 2)) + tmp94 = einsum(t1, (0, 1), tmp93, (2, 1), (0, 2)) + tmp92 = einsum(t1, (0, 1), tmp90, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp91 = einsum(t1, (0, 1), tmp90, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp88 = einsum(t1, (0, 1), tmp13, (2, 0), (2, 1)) + tmp87 = einsum(t1, (0, 1), tmp12, (2, 0), (2, 1)) + tmp82 = einsum(tmp81, (0, 1, 2, 3), t1, (3, 4), (0, 1, 2, 4)) + tmp78 = einsum(t1, (0, 1), tmp22, (2, 0), (2, 1)) + tmp75 = einsum(tmp24, (0, 1), t1, (1, 2), (0, 2)) + tmp73 = einsum(tmp20, (0, 1, 2, 3), t2, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp72 = einsum(tmp20, (0, 1, 2, 3), t2, (4, 2, 3, 5), (0, 4, 1, 5)) + tmp70 = einsum(tmp20, (0, 1, 2, 3), t2, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp69 = einsum(tmp20, (0, 1, 2, 3), t2, (4, 1, 3, 5), (0, 4, 2, 5)) + tmp66 = einsum(tmp20, (0, 1, 2, 3), t2, (2, 1, 3, 4), (0, 4)) + tmp63 = einsum(tmp20, (0, 1, 2, 3), t2, (1, 2, 3, 4), (0, 4)) + tmp60 = einsum(tmp17, (0, 1), t2, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp57 = einsum(t2, (0, 1, 2, 3), tmp47, (4, 3), (0, 1, 4, 2)) + tmp54 = einsum(tmp17, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp51 = einsum(t2, (0, 1, 2, 3), tmp17, (1, 2), (0, 3)) + tmp49 = einsum(tmp47, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp48 = einsum(t2, (0, 1, 2, 3), tmp47, (1, 2), (0, 3)) + tmp44 = einsum(t2, (0, 1, 2, 3), v.ovvv, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp41 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 1, 3), (4, 2)) + tmp38 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 3, 1), (4, 2)) + tmp36 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp35 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 5, 1, 2), (0, 4, 5, 3)) + tmp33 = einsum(v.ooov, (0, 1, 2, 3), t2, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp32 = einsum(v.ooov, (0, 1, 2, 3), t2, (4, 1, 3, 5), (4, 0, 2, 5)) + tmp29 = einsum(v.ooov, (0, 1, 2, 3), t2, (2, 1, 3, 4), (0, 4)) + tmp26 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 0, 3), (4, 2)) + tmp21 = einsum(t1, (0, 1), v.oovv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp19 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp14 = einsum(t1, (0, 1), v.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp9 = einsum(tmp0, (0, 1), t1, (0, 2), (1, 2)) + tmp6 = einsum(f.ov, (0, 1), t2, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp4 = einsum(t2, (0, 1, 2, 3), f.ov, (1, 3), (0, 2)) + tmp3 = einsum(t2, (0, 1, 2, 3), f.ov, (1, 2), (0, 3)) + tmp2 = einsum(t1, (0, 1), f.vv, (2, 1), (0, 2)) + tmp1 = einsum(f.oo, (0, 1), t1, (1, 2), (0, 2)) + + return {f"tmp0": tmp0, f"tmp1": tmp1, f"tmp100": tmp100, f"tmp103": tmp103, f"tmp104": tmp104, f"tmp107": tmp107, f"tmp108": tmp108, f"tmp112": tmp112, f"tmp113": tmp113, f"tmp114": tmp114, f"tmp116": tmp116, f"tmp117": tmp117, f"tmp12": tmp12, f"tmp13": tmp13, f"tmp134": tmp134, f"tmp136": tmp136, f"tmp14": tmp14, f"tmp17": tmp17, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp21": tmp21, f"tmp22": tmp22, f"tmp24": tmp24, f"tmp26": tmp26, f"tmp29": tmp29, f"tmp3": tmp3, f"tmp32": tmp32, f"tmp33": tmp33, f"tmp35": tmp35, f"tmp36": tmp36, f"tmp38": tmp38, f"tmp4": tmp4, f"tmp41": tmp41, f"tmp44": tmp44, f"tmp47": tmp47, f"tmp48": tmp48, f"tmp49": tmp49, f"tmp51": tmp51, f"tmp54": tmp54, f"tmp57": tmp57, f"tmp6": tmp6, f"tmp60": tmp60, f"tmp63": tmp63, f"tmp66": tmp66, f"tmp69": tmp69, f"tmp70": tmp70, f"tmp72": tmp72, f"tmp73": tmp73, f"tmp75": tmp75, f"tmp78": tmp78, f"tmp81": tmp81, f"tmp82": tmp82, f"tmp85": tmp85, f"tmp86": tmp86, f"tmp87": tmp87, f"tmp88": tmp88, f"tmp9": tmp9, f"tmp90": tmp90, f"tmp91": tmp91, f"tmp92": tmp92, f"tmp93": tmp93, f"tmp94": tmp94, f"tmp97": tmp97, f"tmp98": tmp98, f"tmp99": tmp99} + +def hbar_lmatvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:21:23.798456. + + Parameters + ---------- + f : array + Fock matrix. + r1 : array + R1 amplitudes. + r2 : array + R2 amplitudes. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + r1new : array + Updated R1 residuals. + r2new : array + Updated R2 residuals. + """ + + ints = kwargs["ints"] + tmp18 = t2.transpose((0, 1, 3, 2)).copy() * -0.5 + tmp18 += t2 + tmp15 = f.ov.copy() + tmp15 += ints.tmp17 * 2 + tmp15 += ints.tmp47 * -1 + tmp11 = einsum(t1, (0, 1), r2, (2, 3, 1), (2, 3, 0)) + tmp10 = ints.tmp107.copy() + tmp10 += ints.tmp81 + tmp10 += ints.tmp90.transpose((0, 1, 3, 2)) + tmp10 += v.oooo.transpose((0, 2, 1, 3)) + tmp17 = f.oo.copy() * 0.5 + tmp17 += ints.tmp0.transpose((1, 0)) * 0.5 + tmp17 += ints.tmp13 + tmp17 += ints.tmp24 + tmp17 += ints.tmp86 + tmp17 += ints.tmp12 * -0.5 + tmp17 += ints.tmp22 * -0.5 + tmp17 += ints.tmp85 * -0.5 + tmp14 = ints.tmp20.copy() + tmp14 += v.ooov.transpose((0, 2, 1, 3)) + tmp8 = ints.tmp117.copy() * 2 + tmp8 += ints.tmp99.transpose((0, 1, 3, 2)) + tmp8 += v.ovov.transpose((0, 2, 1, 3)) + tmp8 += ints.tmp114 * -1 + tmp8 += ints.tmp116 * -1 + tmp19 = einsum(r2, (0, 1, 2), tmp18, (1, 0, 3, 2), (3,)) + del tmp18 + tmp7 = r2.copy() + tmp7 += r2.transpose((1, 0, 2)) * -0.5 + tmp9 = ints.tmp112.copy() + tmp9 += v.oovv + tmp9 += ints.tmp113.transpose((0, 1, 3, 2)) * -1 + tmp13 = ints.tmp20.copy() + tmp13 += v.ooov.transpose((0, 2, 1, 3)) + tmp16 = ints.tmp136.copy() * 2 + tmp16 += ints.tmp97.transpose((1, 0)) + tmp16 += f.vv * -1 + tmp16 += ints.tmp134 * -1 + tmp16 += ints.tmp93 * -2 + tmp16 += einsum(tmp15, (0, 1), t1, (0, 2), (2, 1)) + tmp12 = tmp11.copy() * -0.5 + tmp12 += tmp11.transpose((1, 0, 2)) + tmp0 = r2.copy() * -0.5 + tmp0 += r2.transpose((1, 0, 2)) + tmp2 = r2.copy() * 2 + tmp2 += r2.transpose((1, 0, 2)) * -1 + tmp5 = ints.tmp104.copy() * 2 + tmp5 += ints.tmp19 + tmp5 += ints.tmp1 + tmp5 += ints.tmp29 * 2 + tmp5 += ints.tmp3 + tmp5 += ints.tmp41 + tmp5 += ints.tmp49 * 2 + tmp5 += ints.tmp51 * 2 + tmp5 += ints.tmp63 * 2 + tmp5 += ints.tmp75 * 2 + tmp5 += ints.tmp88 * 2 + tmp5 += ints.tmp98 + tmp5 += ints.tmp9 + tmp5 += f.ov * -1 + tmp5 += ints.tmp103 * -1 + tmp5 += ints.tmp17 * -2 + tmp5 += ints.tmp26 * -1 + tmp5 += ints.tmp2 * -1 + tmp5 += ints.tmp38 * -2 + tmp5 += ints.tmp48 * -1 + tmp5 += ints.tmp4 * -2 + tmp5 += ints.tmp54 * -4 + tmp5 += ints.tmp66 * -1 + tmp5 += ints.tmp78 * -1 + tmp5 += ints.tmp87 * -1 + tmp5 += ints.tmp94 * -2 + tmp3 = ints.tmp33.transpose((0, 2, 1, 3)).copy() + tmp3 += ints.tmp35 + tmp3 += ints.tmp57.transpose((0, 2, 1, 3)) + tmp3 += ints.tmp72.transpose((0, 2, 1, 3)) + tmp3 += ints.tmp92 + tmp3 += ints.tmp21 * -1 + tmp3 += ints.tmp36 * -2 + tmp3 += ints.tmp60.transpose((0, 2, 1, 3)) * -2 + tmp3 += ints.tmp6.transpose((1, 0, 2, 3)) * -1 + tmp6 = f.oo.copy() + tmp6 += ints.tmp0.transpose((1, 0)) + tmp6 += ints.tmp13.transpose((1, 0)) * 2 + tmp6 += ints.tmp24 * 2 + tmp6 += ints.tmp86 * 2 + tmp6 += ints.tmp12 * -1 + tmp6 += ints.tmp22 * -1 + tmp6 += ints.tmp85 * -1 + tmp1 = ints.tmp108.copy() + tmp1 += ints.tmp14.transpose((1, 2, 0, 3)) + tmp1 += ints.tmp32 + tmp1 += ints.tmp69 + tmp1 += ints.tmp73 + tmp1 += ints.tmp82 + tmp1 += ints.tmp91 + tmp1 += ints.tmp100 * -1 + tmp1 += ints.tmp20 * -1 + tmp1 += ints.tmp44 * -1 + tmp1 += ints.tmp70 * -2 + tmp4 = v.ooov.copy() * -0.5 + tmp4 += v.ovoo.transpose((0, 2, 3, 1)) + r2new = einsum(r2, (0, 1, 2), ints.tmp90, (1, 0, 3, 4), (3, 4, 2)) + r2new += einsum(tmp8, (0, 1, 2, 3), tmp7, (0, 4, 2), (1, 4, 3)) * 2 + del tmp8, tmp7 + r2new += einsum(r2, (0, 1, 2), tmp9, (1, 3, 4, 2), (0, 3, 4)) * -1 + r2new += einsum(tmp9, (0, 1, 2, 3), r2, (0, 4, 3), (1, 4, 2)) * -1 + del tmp9 + r2new += einsum(tmp10, (0, 1, 2, 3), r2, (0, 1, 4), (2, 3, 4)) + del tmp10 + r2new += einsum(tmp12, (0, 1, 2), tmp13, (1, 3, 2, 4), (3, 0, 4)) * -2 + del tmp12, tmp13 + r2new += einsum(tmp14, (0, 1, 2, 3), tmp11, (4, 0, 1), (4, 2, 3)) + r2new += einsum(tmp11, (0, 1, 2), tmp14, (0, 2, 3, 4), (3, 1, 4)) + del tmp11 + r2new += einsum(tmp16, (0, 1), r2, (2, 3, 0), (2, 3, 1)) * -1 + del tmp16 + r2new += einsum(r2, (0, 1, 2), tmp17, (0, 3), (3, 1, 2)) * -2 + r2new += einsum(tmp17, (0, 1), r2, (2, 0, 3), (2, 1, 3)) * -2 + del tmp17 + r2new += einsum(v.ovov, (0, 1, 2, 3), tmp19, (3,), (0, 2, 1)) * -2 + del tmp19 + r2new += einsum(r1, (0,), tmp14, (0, 1, 2, 3), (1, 2, 3)) + del tmp14 + r2new += einsum(r1, (0,), tmp15, (1, 2), (1, 0, 2)) * -1 + del tmp15 + r1new = einsum(tmp0, (0, 1, 2), tmp1, (0, 1, 3, 2), (3,)) * -2 + del tmp0, tmp1 + r1new += einsum(tmp3, (0, 1, 2, 3), tmp2, (0, 2, 3), (1,)) * -1 + del tmp3 + r1new += einsum(tmp4, (0, 1, 2, 3), r2, (0, 2, 3), (1,)) * 2 + del tmp4 + r1new += einsum(tmp5, (0, 1), tmp2, (0, 2, 1), (2,)) + del tmp2, tmp5 + r1new += einsum(tmp6, (0, 1), r1, (0,), (1,)) * -1 + del tmp6 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ea_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:21:55.505232. + + Parameters + ---------- + f : array + Fock matrix. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + tmp1 : array + tmp10 : array + tmp103 : array + tmp106 : array + tmp107 : array + tmp109 : array + tmp11 : array + tmp110 : array + tmp111 : array + tmp112 : array + tmp113 : array + tmp14 : array + tmp16 : array + tmp17 : array + tmp19 : array + tmp2 : array + tmp24 : array + tmp27 : array + tmp29 : array + tmp3 : array + tmp31 : array + tmp34 : array + tmp37 : array + tmp4 : array + tmp40 : array + tmp43 : array + tmp46 : array + tmp48 : array + tmp51 : array + tmp53 : array + tmp55 : array + tmp56 : array + tmp57 : array + tmp59 : array + tmp62 : array + tmp69 : array + tmp70 : array + tmp73 : array + tmp76 : array + tmp79 : array + tmp80 : array + tmp83 : array + tmp84 : array + tmp87 : array + tmp88 : array + tmp90 : array + tmp92 : array + tmp95 : array + tmp96 : array + tmp97 : array + tmp98 : array + """ + + tmp17 = einsum(v.ovov, (0, 1, 2, 3), t1, (2, 3), (0, 1)) + tmp55 = einsum(t1, (0, 1), v.ovov, (2, 1, 0, 3), (2, 3)) + tmp112 = einsum(t1, (0, 1), tmp17, (2, 1), (0, 2)) + tmp110 = einsum(t1, (0, 1), tmp55, (2, 1), (0, 2)) + tmp16 = einsum(t1, (0, 1), v.ovvv, (0, 2, 3, 1), (2, 3)) + tmp14 = einsum(v.ovvv, (0, 1, 2, 3), t1, (0, 1), (2, 3)) + tmp97 = einsum(v.ooov, (0, 1, 2, 3), t1, (2, 3), (0, 1)) + tmp95 = einsum(v.ooov, (0, 1, 2, 3), t1, (1, 3), (0, 2)) + tmp83 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 3, 1), (4, 0)) + tmp79 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 1, 3), (4, 0)) + tmp69 = einsum(t1, (0, 1), v.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp10 = einsum(f.ov, (0, 1), t1, (2, 1), (0, 2)) + tmp113 = einsum(tmp112, (0, 1), t1, (1, 2), (0, 2)) + tmp111 = einsum(tmp110, (0, 1), t1, (1, 2), (0, 2)) + tmp109 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 3), (4, 0, 1, 2)) + tmp107 = einsum(v.ovvv, (0, 1, 2, 3), t1, (4, 1), (4, 0, 2, 3)) + tmp106 = einsum(tmp16, (0, 1), t1, (2, 0), (2, 1)) + tmp103 = einsum(t1, (0, 1), tmp14, (2, 1), (0, 2)) + tmp98 = einsum(tmp97, (0, 1), t1, (1, 2), (0, 2)) + tmp96 = einsum(t1, (0, 1), tmp95, (2, 0), (2, 1)) + tmp92 = einsum(v.ovov, (0, 1, 2, 3), t2, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp90 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 2, 1, 5), (0, 4, 3, 5)) + tmp88 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 5, 1, 3), (0, 4, 2, 5)) + tmp87 = einsum(t2, (0, 1, 2, 3), v.ovov, (4, 5, 1, 2), (0, 4, 3, 5)) + tmp84 = einsum(tmp83, (0, 1), t1, (1, 2), (0, 2)) + tmp80 = einsum(t1, (0, 1), tmp79, (2, 0), (2, 1)) + tmp76 = einsum(tmp69, (0, 1, 2, 3), t2, (2, 1, 4, 5), (0, 5, 4, 3)) + tmp73 = einsum(tmp69, (0, 1, 2, 3), t2, (2, 1, 3, 4), (0, 4)) + tmp70 = einsum(t2, (0, 1, 2, 3), tmp69, (4, 0, 1, 2), (4, 3)) + tmp62 = einsum(tmp17, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp59 = einsum(t2, (0, 1, 2, 3), tmp17, (1, 2), (0, 3)) + tmp57 = einsum(tmp55, (0, 1), t2, (2, 0, 3, 1), (2, 3)) + tmp56 = einsum(t2, (0, 1, 2, 3), tmp55, (1, 2), (0, 3)) + tmp53 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 5, 3), (4, 5, 1, 2)) + tmp51 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 4, 5, 2), (0, 3, 4, 5)) + tmp48 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 3, 4, 5), (0, 2, 4, 5)) + tmp46 = einsum(t2, (0, 1, 2, 3), v.ovvv, (1, 2, 4, 5), (0, 3, 4, 5)) + tmp43 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 1, 3), (4, 2)) + tmp40 = einsum(v.ovvv, (0, 1, 2, 3), t2, (4, 0, 3, 1), (4, 2)) + tmp37 = einsum(v.ooov, (0, 1, 2, 3), t2, (2, 1, 4, 5), (0, 5, 4, 3)) + tmp34 = einsum(v.ooov, (0, 1, 2, 3), t2, (2, 1, 3, 4), (0, 4)) + tmp31 = einsum(t2, (0, 1, 2, 3), v.ooov, (4, 1, 0, 3), (4, 2)) + tmp29 = einsum(t2, (0, 1, 2, 3), v.ovov, (0, 4, 1, 3), (2, 4)) + tmp27 = einsum(t2, (0, 1, 2, 3), v.ovov, (0, 4, 1, 2), (3, 4)) + tmp24 = einsum(t1, (0, 1), v.vvvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp19 = einsum(t1, (0, 1), v.oovv, (2, 0, 3, 1), (2, 3)) + tmp11 = einsum(t1, (0, 1), tmp10, (0, 2), (2, 1)) + tmp4 = einsum(t2, (0, 1, 2, 3), f.ov, (1, 3), (0, 2)) + tmp3 = einsum(t2, (0, 1, 2, 3), f.ov, (1, 2), (0, 3)) + tmp2 = einsum(f.vv, (0, 1), t1, (2, 1), (2, 0)) + tmp1 = einsum(t1, (0, 1), f.oo, (2, 0), (2, 1)) + + return {f"tmp1": tmp1, f"tmp10": tmp10, f"tmp103": tmp103, f"tmp106": tmp106, f"tmp107": tmp107, f"tmp109": tmp109, f"tmp11": tmp11, f"tmp110": tmp110, f"tmp111": tmp111, f"tmp112": tmp112, f"tmp113": tmp113, f"tmp14": tmp14, f"tmp16": tmp16, f"tmp17": tmp17, f"tmp19": tmp19, f"tmp2": tmp2, f"tmp24": tmp24, f"tmp27": tmp27, f"tmp29": tmp29, f"tmp3": tmp3, f"tmp31": tmp31, f"tmp34": tmp34, f"tmp37": tmp37, f"tmp4": tmp4, f"tmp40": tmp40, f"tmp43": tmp43, f"tmp46": tmp46, f"tmp48": tmp48, f"tmp51": tmp51, f"tmp53": tmp53, f"tmp55": tmp55, f"tmp56": tmp56, f"tmp57": tmp57, f"tmp59": tmp59, f"tmp62": tmp62, f"tmp69": tmp69, f"tmp70": tmp70, f"tmp73": tmp73, f"tmp76": tmp76, f"tmp79": tmp79, f"tmp80": tmp80, f"tmp83": tmp83, f"tmp84": tmp84, f"tmp87": tmp87, f"tmp88": tmp88, f"tmp90": tmp90, f"tmp92": tmp92, f"tmp95": tmp95, f"tmp96": tmp96, f"tmp97": tmp97, f"tmp98": tmp98} + +def hbar_lmatvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:21:55.528470. + + Parameters + ---------- + f : array + Fock matrix. + r1 : array + R1 amplitudes. + r2 : array + R2 amplitudes. + t1 : array + T1 amplitudes. + t2 : array + T2 amplitudes. + v : array + Electron repulsion integrals. + + Returns + ------- + r1new : array + Updated R1 residuals. + r2new : array + Updated R2 residuals. + """ + + ints = kwargs["ints"] + tmp19 = f.ov.copy() + tmp19 += ints.tmp17 * 2 + tmp19 += ints.tmp55 * -1 + tmp16 = t2.transpose((0, 1, 3, 2)).copy() * -1 + tmp16 += t2 * 2 + tmp22 = ints.tmp69.copy() + tmp22 += v.ooov.transpose((0, 2, 1, 3)) + tmp10 = einsum(t1, (0, 1), r2, (2, 1, 3), (3, 0, 2)) + tmp26 = einsum(t1, (0, 1), tmp19, (0, 2), (1, 2)) + tmp17 = einsum(tmp16, (0, 1, 2, 3), r2, (2, 3, 0), (1,)) * 0.5 + del tmp16 + tmp15 = einsum(t1, (0, 1), r1, (1,), (0,)) + tmp24 = einsum(tmp22, (0, 1, 2, 3), t1, (1, 4), (0, 2, 4, 3)) + tmp2 = r2.transpose((2, 0, 1)).copy() + tmp2 += r2.transpose((2, 1, 0)) * -0.5 + tmp5 = r2.transpose((2, 0, 1)).copy() * -0.5 + tmp5 += r2.transpose((2, 1, 0)) + tmp11 = einsum(t1, (0, 1), tmp10, (2, 3, 1), (2, 0, 3)) + tmp28 = f.oo.copy() + tmp28 += ints.tmp10.transpose((1, 0)) + tmp28 += ints.tmp112 * 2 + tmp28 += ints.tmp79 * 2 + tmp28 += ints.tmp97 * 2 + tmp28 += ints.tmp110 * -1 + tmp28 += ints.tmp83 * -1 + tmp28 += ints.tmp95 * -1 + tmp27 = ints.tmp16.transpose((1, 0)).copy() + tmp27 += ints.tmp29 * 2 + tmp27 += f.vv * -1 + tmp27 += ints.tmp14 * -2 + tmp27 += ints.tmp27 * -1 + tmp27 += tmp26 + del tmp26 + tmp20 = einsum(t2, (0, 1, 2, 3), r2, (2, 3, 4), (4, 0, 1)) + tmp18 = tmp15.copy() * 0.5 + del tmp15 + tmp18 += tmp17 * -1 + del tmp17 + tmp21 = einsum(r2, (0, 1, 2), t1, (3, 0), (2, 3, 1)) + tmp23 = ints.tmp87.transpose((0, 1, 3, 2)).copy() + tmp23 += ints.tmp92.transpose((0, 1, 3, 2)) + tmp23 += ints.tmp109 * -1 + tmp23 += ints.tmp88.transpose((0, 1, 3, 2)) * -2 + tmp23 += v.ovov.transpose((0, 2, 3, 1)) * -1 + tmp23 += einsum(tmp22, (0, 1, 2, 3), t1, (2, 4), (0, 1, 3, 4)) + del tmp22 + tmp25 = ints.tmp90.transpose((0, 1, 3, 2)).copy() + tmp25 += ints.tmp107 * -1 + tmp25 += v.oovv * -1 + tmp25 += tmp24.transpose((0, 1, 3, 2)) + del tmp24 + tmp0 = ints.tmp24.copy() + tmp0 += ints.tmp46.transpose((0, 2, 1, 3)) * 2 + tmp0 += ints.tmp53.transpose((0, 2, 1, 3)) * 2 + tmp0 += ints.tmp76.transpose((0, 3, 1, 2)) + tmp0 += ints.tmp37.transpose((0, 3, 1, 2)) * -2 + tmp0 += ints.tmp48.transpose((0, 2, 1, 3)) * -4 + tmp0 += ints.tmp51.transpose((0, 2, 1, 3)) * -1 + tmp0 += v.ovvv.transpose((0, 2, 1, 3)) * -2 + tmp0 += v.ovvv.transpose((0, 2, 3, 1)) + tmp14 = f.vv.copy() + tmp14 += ints.tmp14.transpose((1, 0)) * 2 + tmp14 += ints.tmp27 + tmp14 += ints.tmp16.transpose((1, 0)) * -1 + tmp14 += ints.tmp29 * -2 + tmp7 = ints.tmp109.copy() + tmp7 += ints.tmp88.transpose((0, 1, 3, 2)) * 2 + tmp7 += v.ovov.transpose((0, 2, 3, 1)) + tmp7 += ints.tmp87.transpose((0, 1, 3, 2)) * -1 + tmp7 += ints.tmp92.transpose((0, 1, 3, 2)) * -1 + tmp8 = ints.tmp106.copy() + tmp8 += ints.tmp113 * 2 + tmp8 += ints.tmp11 + tmp8 += ints.tmp19 + tmp8 += ints.tmp1 + tmp8 += ints.tmp34 * 2 + tmp8 += ints.tmp3 + tmp8 += ints.tmp43 + tmp8 += ints.tmp57 * 2 + tmp8 += ints.tmp59 * 2 + tmp8 += ints.tmp70 * 2 + tmp8 += ints.tmp80 * 2 + tmp8 += ints.tmp98 * 2 + tmp8 += f.ov * -1 + tmp8 += ints.tmp103 * -2 + tmp8 += ints.tmp111 * -1 + tmp8 += ints.tmp17 * -2 + tmp8 += ints.tmp2 * -1 + tmp8 += ints.tmp31 * -1 + tmp8 += ints.tmp40 * -2 + tmp8 += ints.tmp4 * -2 + tmp8 += ints.tmp56 * -1 + tmp8 += ints.tmp62 * -4 + tmp8 += ints.tmp73 * -1 + tmp8 += ints.tmp84 * -1 + tmp8 += ints.tmp96 * -1 + tmp9 = r2.transpose((2, 0, 1)).copy() * 2 + tmp9 += r2.transpose((2, 1, 0)) * -1 + tmp3 = einsum(tmp2, (0, 1, 2), t1, (3, 1), (0, 3, 2)) + tmp6 = einsum(t1, (0, 1), tmp5, (2, 1, 3), (2, 0, 3)) * 2 + del tmp5 + tmp13 = tmp11.copy() * 2 + tmp13 += tmp11.transpose((0, 2, 1)) * -1 + tmp1 = ints.tmp24.copy() + tmp1 += ints.tmp46.transpose((0, 2, 1, 3)) * 0.5 + tmp1 += ints.tmp53.transpose((0, 2, 1, 3)) * 0.5 + tmp1 += ints.tmp76.transpose((0, 3, 1, 2)) + tmp1 += ints.tmp37.transpose((0, 3, 1, 2)) * -0.5 + tmp1 += ints.tmp48.transpose((0, 2, 1, 3)) * -1 + tmp1 += ints.tmp51.transpose((0, 2, 1, 3)) * -1 + tmp4 = ints.tmp107.copy() + tmp4 += v.oovv + tmp4 += ints.tmp90.transpose((0, 1, 3, 2)) * -1 + tmp12 = tmp11.copy() * -0.5 + tmp12 += tmp11.transpose((0, 2, 1)) + r2new = einsum(v.ovov, (0, 1, 2, 3), tmp20, (4, 2, 0), (3, 1, 4)) + del tmp20 + r2new += einsum(tmp11, (0, 1, 2), v.ovov, (1, 3, 2, 4), (3, 4, 0)) + del tmp11 + r2new += einsum(v.ovvv, (0, 1, 2, 3), tmp21, (4, 0, 3), (1, 2, 4)) * -1 + del tmp21 + r2new += einsum(v.ovvv, (0, 1, 2, 3), tmp10, (4, 0, 3), (2, 1, 4)) * -1 + del tmp10 + r2new += einsum(r1, (0,), v.ovvv, (1, 2, 3, 0), (2, 3, 1)) * -1 + r2new += einsum(r2, (0, 1, 2), v.vvvv, (3, 0, 4, 1), (3, 4, 2)) + r2new += einsum(tmp23, (0, 1, 2, 3), tmp2, (0, 3, 4), (2, 4, 1)) * -2 + del tmp2, tmp23 + r2new += einsum(tmp25, (0, 1, 2, 3), r2, (4, 3, 0), (4, 2, 1)) + r2new += einsum(tmp25, (0, 1, 2, 3), r2, (3, 4, 0), (2, 4, 1)) + del tmp25 + r2new += einsum(r2, (0, 1, 2), tmp27, (0, 3), (3, 1, 2)) * -1 + r2new += einsum(tmp27, (0, 1), r2, (2, 0, 3), (2, 1, 3)) * -1 + del tmp27 + r2new += einsum(r2, (0, 1, 2), tmp28, (2, 3), (0, 1, 3)) * -1 + del tmp28 + r2new += einsum(v.ovov, (0, 1, 2, 3), tmp18, (2,), (1, 3, 0)) * 2 + r2new += einsum(tmp19, (0, 1), r1, (2,), (1, 2, 0)) * -1 + r1new = einsum(tmp0, (0, 1, 2, 3), r2, (2, 3, 0), (1,)) + del tmp0 + r1new += einsum(tmp1, (0, 1, 2, 3), r2, (3, 2, 0), (1,)) * -2 + del tmp1 + r1new += einsum(tmp3, (0, 1, 2), tmp4, (0, 1, 3, 2), (3,)) * 2 + del tmp3, tmp4 + r1new += einsum(tmp7, (0, 1, 2, 3), tmp6, (0, 1, 3), (2,)) + del tmp7, tmp6 + r1new += einsum(tmp9, (0, 1, 2), tmp8, (0, 1), (2,)) + del tmp9, tmp8 + r1new += einsum(ints.tmp69, (0, 1, 2, 3), tmp12, (0, 1, 2), (3,)) * -2 + del tmp12 + r1new += einsum(v.ooov, (0, 1, 2, 3), tmp13, (0, 1, 2), (3,)) * -1 + del tmp13 + r1new += einsum(tmp14, (0, 1), r1, (0,), (1,)) + del tmp14 + r1new += einsum(tmp19, (0, 1), tmp18, (0,), (1,)) * -2 + del tmp19, tmp18 + + return {f"r1new": r1new, f"r2new": r2new} + diff --git a/ebcc/codegen/UCCSD.py b/ebcc/codegen/UCCSD.py index d67ec79b..98293d79 100644 --- a/ebcc/codegen/UCCSD.py +++ b/ebcc/codegen/UCCSD.py @@ -6255,3 +6255,3396 @@ def hbar_matvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs) return {f"r1new": r1new, f"r2new": r2new} +def hbar_lmatvec_ip_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:23:01.202553. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + tmp1 : array + tmp10 : array + tmp100 : array + tmp101 : array + tmp103 : array + tmp105 : array + tmp107 : array + tmp109 : array + tmp11 : array + tmp111 : array + tmp113 : array + tmp115 : array + tmp117 : array + tmp119 : array + tmp120 : array + tmp122 : array + tmp124 : array + tmp125 : array + tmp127 : array + tmp129 : array + tmp13 : array + tmp130 : array + tmp132 : array + tmp133 : array + tmp135 : array + tmp137 : array + tmp138 : array + tmp140 : array + tmp141 : array + tmp143 : array + tmp144 : array + tmp146 : array + tmp148 : array + tmp149 : array + tmp15 : array + tmp151 : array + tmp152 : array + tmp154 : array + tmp155 : array + tmp156 : array + tmp157 : array + tmp159 : array + tmp161 : array + tmp162 : array + tmp163 : array + tmp164 : array + tmp165 : array + tmp167 : array + tmp168 : array + tmp169 : array + tmp17 : array + tmp170 : array + tmp172 : array + tmp174 : array + tmp175 : array + tmp176 : array + tmp177 : array + tmp178 : array + tmp179 : array + tmp181 : array + tmp182 : array + tmp184 : array + tmp185 : array + tmp186 : array + tmp187 : array + tmp188 : array + tmp189 : array + tmp19 : array + tmp190 : array + tmp191 : array + tmp193 : array + tmp194 : array + tmp196 : array + tmp197 : array + tmp199 : array + tmp2 : array + tmp201 : array + tmp203 : array + tmp204 : array + tmp205 : array + tmp206 : array + tmp207 : array + tmp209 : array + tmp21 : array + tmp210 : array + tmp211 : array + tmp212 : array + tmp214 : array + tmp215 : array + tmp22 : array + tmp223 : array + tmp225 : array + tmp230 : array + tmp232 : array + tmp238 : array + tmp240 : array + tmp247 : array + tmp248 : array + tmp25 : array + tmp250 : array + tmp251 : array + tmp253 : array + tmp254 : array + tmp256 : array + tmp26 : array + tmp262 : array + tmp264 : array + tmp27 : array + tmp275 : array + tmp277 : array + tmp279 : array + tmp28 : array + tmp281 : array + tmp283 : array + tmp285 : array + tmp291 : array + tmp292 : array + tmp294 : array + tmp295 : array + tmp297 : array + tmp299 : array + tmp30 : array + tmp301 : array + tmp306 : array + tmp307 : array + tmp309 : array + tmp314 : array + tmp315 : array + tmp317 : array + tmp319 : array + tmp32 : array + tmp320 : array + tmp324 : array + tmp325 : array + tmp327 : array + tmp328 : array + tmp333 : array + tmp334 : array + tmp336 : array + tmp34 : array + tmp346 : array + tmp349 : array + tmp351 : array + tmp353 : array + tmp355 : array + tmp357 : array + tmp359 : array + tmp36 : array + tmp361 : array + tmp37 : array + tmp38 : array + tmp39 : array + tmp391 : array + tmp393 : array + tmp4 : array + tmp41 : array + tmp422 : array + tmp425 : array + tmp426 : array + tmp428 : array + tmp43 : array + tmp430 : array + tmp432 : array + tmp434 : array + tmp436 : array + tmp438 : array + tmp449 : array + tmp45 : array + tmp451 : array + tmp453 : array + tmp46 : array + tmp47 : array + tmp49 : array + tmp5 : array + tmp51 : array + tmp53 : array + tmp55 : array + tmp57 : array + tmp59 : array + tmp61 : array + tmp62 : array + tmp64 : array + tmp65 : array + tmp66 : array + tmp68 : array + tmp7 : array + tmp70 : array + tmp72 : array + tmp74 : array + tmp76 : array + tmp78 : array + tmp8 : array + tmp80 : array + tmp82 : array + tmp83 : array + tmp85 : array + tmp86 : array + tmp88 : array + tmp89 : array + tmp90 : array + tmp92 : array + tmp94 : array + tmp96 : array + tmp98 : array + """ + + tmp45 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 0, 2, 3)) + tmp119 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp41 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t1.aa, (4, 3), (4, 0, 2, 1)) + tmp38 = einsum(t1.aa, (0, 1), v.aabb.ovov, (0, 1, 2, 3), (2, 3)) + tmp39 = einsum(t1.bb, (0, 1), v.aabb.ovov, (2, 3, 0, 1), (2, 3)) + tmp36 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 0, 1), (2, 3)) + tmp89 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 1, 0, 3), (2, 3)) + tmp32 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 3, 0, 1), (2, 3)) + tmp82 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 1, 0, 3), (2, 3)) + tmp214 = einsum(t1.bb, (0, 1), tmp45, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp333 = einsum(t1.bb, (0, 1), tmp119, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp327 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (4, 3), (4, 2, 0, 1)) + tmp324 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp174 = einsum(t1.aa, (0, 1), v.aabb.ovoo, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp176 = einsum(v.aabb.ooov, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp314 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp151 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp306 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovov, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp124 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 2, 1)) + tmp211 = einsum(t1.aa, (0, 1), tmp41, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp209 = einsum(t1.bb, (0, 1), tmp38, (2, 1), (0, 2)) + tmp156 = einsum(t1.aa, (0, 1), tmp39, (2, 1), (0, 2)) + tmp205 = einsum(tmp36, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp203 = einsum(tmp89, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp155 = einsum(t1.aa, (0, 1), tmp32, (2, 1), (0, 2)) + tmp154 = einsum(tmp82, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp196 = einsum(t1.aa, (0, 1), v.aabb.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp193 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp190 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp188 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.aa, (0, 1), (2, 3)) + tmp186 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 3), (1, 2)) + tmp184 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 1), (2, 3)) + tmp181 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 2, 3, 1), (2, 3)) + tmp178 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 1, 2, 3), (2, 3)) + tmp169 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp167 = einsum(t1.aa, (0, 1), v.aabb.ovoo, (0, 1, 2, 3), (2, 3)) + tmp27 = einsum(t1.bb, (0, 1), v.aabb.ooov, (2, 3, 0, 1), (2, 3)) + tmp163 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp161 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (1, 3), (0, 2)) + tmp26 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 3, 0, 1), (2, 3)) + tmp25 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 0, 3, 1), (2, 3)) + tmp148 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (4, 3, 5, 2), (0, 1, 4, 5)) * -1 + tmp49 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 3), (4, 0)) + tmp143 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp140 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 1, 3), (4, 0)) + tmp47 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 1, 3), (4, 0)) + tmp21 = einsum(t1.bb, (0, 1), f.bb.ov, (2, 1), (2, 0)) + tmp1 = einsum(f.aa.ov, (0, 1), t1.aa, (2, 1), (0, 2)) + tmp453 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 5), (4, 0, 5, 3)) + tmp451 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 2, 1, 4), (4, 3)) + tmp449 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (0, 2, 4, 3), (4, 1)) + tmp438 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 5, 3)) + tmp436 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 2, 5, 3)) + tmp434 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp432 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovov, (4, 5, 1, 3), (0, 4, 2, 5)) + tmp430 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovov, (4, 3, 1, 5), (0, 4, 2, 5)) + tmp428 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp426 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 2, 0, 3)) + tmp425 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 1), (4, 0, 2, 3)) + tmp422 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 5, 3), (1, 5, 2, 4)) + tmp393 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 1, 3), (2, 4)) + tmp391 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (0, 3, 1, 4), (2, 4)) * -1 + tmp361 = einsum(t2.bbbb, (0, 1, 2, 3), v.aabb.ovov, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp359 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp357 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovov, (4, 5, 0, 2), (4, 1, 5, 3)) + tmp355 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp353 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.abab, (2, 4, 1, 5), (0, 4, 3, 5)) + tmp351 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp349 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 1, 2)) + tmp346 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp336 = einsum(tmp214, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp334 = einsum(t1.bb, (0, 1), tmp333, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp328 = einsum(t1.aa, (0, 1), tmp327, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp325 = einsum(tmp324, (0, 1, 2, 3), t1.bb, (4, 2), (4, 0, 1, 3)) + tmp320 = einsum(tmp174, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp319 = einsum(tmp176, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp317 = einsum(t1.bb, (0, 1), tmp314, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp315 = einsum(t1.bb, (0, 1), tmp314, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp309 = einsum(tmp151, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp307 = einsum(t1.bb, (0, 1), tmp306, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp301 = einsum(tmp45, (0, 1, 2, 3), t2.abab, (1, 4, 5, 3), (0, 4, 2, 5)) + tmp299 = einsum(t2.abab, (0, 1, 2, 3), tmp124, (0, 4, 5, 2), (4, 1, 5, 3)) + tmp297 = einsum(tmp124, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 3), (4, 1, 2, 5)) + tmp295 = einsum(t2.bbbb, (0, 1, 2, 3), tmp119, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp294 = einsum(t2.abab, (0, 1, 2, 3), tmp119, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp292 = einsum(t2.bbbb, (0, 1, 2, 3), tmp119, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp291 = einsum(tmp119, (0, 1, 2, 3), t2.abab, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp285 = einsum(tmp38, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp283 = einsum(tmp38, (0, 1), t2.abab, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp281 = einsum(tmp36, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp279 = einsum(tmp36, (0, 1), t2.abab, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp277 = einsum(tmp89, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp275 = einsum(tmp89, (0, 1), t2.abab, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp264 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 5, 3), (0, 1, 5, 4)) + tmp262 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovvv, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp256 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 3, 5)) + tmp254 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 2, 3, 5)) + tmp253 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ooov, (4, 0, 5, 3), (4, 1, 5, 2)) + tmp251 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp250 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp248 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp247 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.abab, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp240 = einsum(t1.aa, (0, 1), v.aabb.vvoo, (2, 1, 3, 4), (0, 3, 4, 2)) + tmp238 = einsum(t1.bb, (0, 1), v.bbbb.oovv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp232 = einsum(v.aabb.oooo, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp230 = einsum(t1.bb, (0, 1), v.bbbb.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp225 = einsum(t2.bbbb, (0, 1, 2, 3), f.bb.ov, (4, 3), (4, 0, 1, 2)) + tmp223 = einsum(t2.abab, (0, 1, 2, 3), f.bb.ov, (4, 3), (0, 4, 1, 2)) + tmp215 = einsum(t1.bb, (0, 1), tmp214, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp212 = einsum(t1.aa, (0, 1), tmp211, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp210 = einsum(t1.bb, (0, 1), tmp209, (2, 0), (2, 1)) + tmp207 = einsum(tmp156, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp206 = einsum(t1.bb, (0, 1), tmp205, (2, 0), (2, 1)) + tmp204 = einsum(tmp203, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp201 = einsum(tmp155, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp199 = einsum(tmp154, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp197 = einsum(tmp196, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp194 = einsum(tmp193, (0, 1, 2, 3), t1.aa, (4, 2), (4, 0, 1, 3)) + tmp191 = einsum(tmp190, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp189 = einsum(t1.bb, (0, 1), tmp188, (2, 1), (0, 2)) + tmp187 = einsum(tmp186, (0, 1), t1.bb, (2, 0), (2, 1)) + tmp185 = einsum(tmp184, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp182 = einsum(tmp181, (0, 1), t1.aa, (2, 0), (2, 1)) + tmp179 = einsum(tmp178, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp177 = einsum(t1.bb, (0, 1), tmp176, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp175 = einsum(t1.bb, (0, 1), tmp174, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp172 = einsum(t1.aa, (0, 1), tmp169, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp170 = einsum(t1.aa, (0, 1), tmp169, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp168 = einsum(tmp167, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp165 = einsum(tmp27, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp164 = einsum(t1.bb, (0, 1), tmp163, (2, 0), (2, 1)) + tmp162 = einsum(tmp161, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp159 = einsum(tmp26, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp157 = einsum(tmp25, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp152 = einsum(t1.bb, (0, 1), tmp151, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp149 = einsum(tmp148, (0, 1, 2, 3), t1.aa, (3, 4), (0, 1, 2, 4)) + tmp146 = einsum(tmp49, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp144 = einsum(t1.bb, (0, 1), tmp143, (2, 0), (2, 1)) + tmp141 = einsum(tmp140, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp138 = einsum(tmp47, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp137 = einsum(t2.abab, (0, 1, 2, 3), tmp124, (4, 5, 1, 2), (0, 4, 5, 3)) + tmp135 = einsum(t2.bbbb, (0, 1, 2, 3), tmp45, (4, 5, 1, 3), (4, 5, 0, 2)) + tmp133 = einsum(tmp45, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp132 = einsum(t2.abab, (0, 1, 2, 3), tmp41, (4, 5, 0, 2), (4, 5, 1, 3)) + tmp130 = einsum(t2.aaaa, (0, 1, 2, 3), tmp41, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp129 = einsum(t2.abab, (0, 1, 2, 3), tmp41, (4, 0, 5, 2), (4, 5, 1, 3)) + tmp127 = einsum(t2.aaaa, (0, 1, 2, 3), tmp41, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp125 = einsum(tmp124, (0, 1, 2, 3), t2.abab, (0, 2, 3, 4), (1, 4)) + tmp122 = einsum(tmp45, (0, 1, 2, 3), t2.abab, (1, 2, 4, 3), (0, 4)) + tmp120 = einsum(t2.bbbb, (0, 1, 2, 3), tmp119, (4, 1, 0, 3), (4, 2)) + tmp117 = einsum(t2.aaaa, (0, 1, 2, 3), tmp41, (4, 0, 1, 3), (4, 2)) * -1 + tmp115 = einsum(t2.abab, (0, 1, 2, 3), tmp39, (4, 2), (0, 4, 1, 3)) + tmp113 = einsum(t2.aaaa, (0, 1, 2, 3), tmp39, (4, 3), (0, 1, 4, 2)) + tmp111 = einsum(tmp32, (0, 1), t2.abab, (2, 3, 1, 4), (2, 0, 3, 4)) + tmp109 = einsum(tmp32, (0, 1), t2.aaaa, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp107 = einsum(tmp82, (0, 1), t2.abab, (2, 3, 1, 4), (2, 0, 3, 4)) + tmp105 = einsum(tmp82, (0, 1), t2.aaaa, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp103 = einsum(t2.bbbb, (0, 1, 2, 3), tmp38, (1, 3), (0, 2)) + tmp101 = einsum(tmp38, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp100 = einsum(t2.abab, (0, 1, 2, 3), tmp39, (0, 2), (1, 3)) + tmp98 = einsum(tmp39, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp96 = einsum(tmp36, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp94 = einsum(tmp36, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp92 = einsum(tmp89, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp90 = einsum(tmp89, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp88 = einsum(tmp32, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp86 = einsum(t2.aaaa, (0, 1, 2, 3), tmp32, (1, 3), (0, 2)) + tmp85 = einsum(tmp82, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp83 = einsum(tmp82, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp80 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp78 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), t2.aaaa, (4, 5, 3, 1), (4, 5, 0, 2)) * -1 + tmp76 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 1, 3), (0, 4)) + tmp74 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp72 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 1, 3), (4, 2)) + tmp70 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 3, 4, 2), (0, 4)) * -1 + tmp68 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp66 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ooov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp65 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovoo, (4, 2, 5, 1), (0, 4, 5, 3)) + tmp64 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.abab, (2, 4, 3, 5), (0, 1, 4, 5)) + tmp62 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ooov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp61 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.abab, (1, 4, 3, 5), (0, 2, 4, 5)) + tmp59 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.aaaa, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp57 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.abab, (1, 2, 4, 3), (0, 4)) + tmp55 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.abab, (0, 3, 1, 4), (2, 4)) + tmp53 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ooov, (4, 0, 1, 3), (4, 2)) + tmp51 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.aaaa, (2, 1, 4, 3), (0, 4)) * -1 + tmp46 = einsum(t1.bb, (0, 1), v.aabb.oovv, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp43 = einsum(t1.aa, (0, 1), v.aaaa.oovv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp37 = einsum(t1.bb, (0, 1), v.bbbb.oovv, (2, 0, 3, 1), (2, 3)) + tmp34 = einsum(t1.aa, (0, 1), v.aaaa.oovv, (2, 0, 3, 1), (2, 3)) + tmp30 = einsum(t1.bb, (0, 1), v.aabb.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp28 = einsum(v.aaaa.oooo, (0, 1, 2, 3), t1.aa, (3, 4), (0, 1, 2, 4)) + tmp22 = einsum(t1.bb, (0, 1), tmp21, (0, 2), (2, 1)) + tmp19 = einsum(tmp1, (0, 1), t1.aa, (0, 2), (1, 2)) + tmp17 = einsum(t2.abab, (0, 1, 2, 3), f.aa.ov, (4, 2), (4, 0, 1, 3)) + tmp15 = einsum(t2.aaaa, (0, 1, 2, 3), f.aa.ov, (4, 3), (4, 0, 1, 2)) + tmp13 = einsum(f.bb.ov, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp11 = einsum(f.bb.ov, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp10 = einsum(f.aa.ov, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp8 = einsum(f.aa.ov, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp7 = einsum(f.bb.vv, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp5 = einsum(f.aa.vv, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp4 = einsum(t1.bb, (0, 1), f.bb.oo, (2, 0), (2, 1)) + tmp2 = einsum(f.aa.oo, (0, 1), t1.aa, (1, 2), (0, 2)) + + return {f"tmp1": tmp1, f"tmp10": tmp10, f"tmp100": tmp100, f"tmp101": tmp101, f"tmp103": tmp103, f"tmp105": tmp105, f"tmp107": tmp107, f"tmp109": tmp109, f"tmp11": tmp11, f"tmp111": tmp111, f"tmp113": tmp113, f"tmp115": tmp115, f"tmp117": tmp117, f"tmp119": tmp119, f"tmp120": tmp120, f"tmp122": tmp122, f"tmp124": tmp124, f"tmp125": tmp125, f"tmp127": tmp127, f"tmp129": tmp129, f"tmp13": tmp13, f"tmp130": tmp130, f"tmp132": tmp132, f"tmp133": tmp133, f"tmp135": tmp135, f"tmp137": tmp137, f"tmp138": tmp138, f"tmp140": tmp140, f"tmp141": tmp141, f"tmp143": tmp143, f"tmp144": tmp144, f"tmp146": tmp146, f"tmp148": tmp148, f"tmp149": tmp149, f"tmp15": tmp15, f"tmp151": tmp151, f"tmp152": tmp152, f"tmp154": tmp154, f"tmp155": tmp155, f"tmp156": tmp156, f"tmp157": tmp157, f"tmp159": tmp159, f"tmp161": tmp161, f"tmp162": tmp162, f"tmp163": tmp163, f"tmp164": tmp164, f"tmp165": tmp165, f"tmp167": tmp167, f"tmp168": tmp168, f"tmp169": tmp169, f"tmp17": tmp17, f"tmp170": tmp170, f"tmp172": tmp172, f"tmp174": tmp174, f"tmp175": tmp175, f"tmp176": tmp176, f"tmp177": tmp177, f"tmp178": tmp178, f"tmp179": tmp179, f"tmp181": tmp181, f"tmp182": tmp182, f"tmp184": tmp184, f"tmp185": tmp185, f"tmp186": tmp186, f"tmp187": tmp187, f"tmp188": tmp188, f"tmp189": tmp189, f"tmp19": tmp19, f"tmp190": tmp190, f"tmp191": tmp191, f"tmp193": tmp193, f"tmp194": tmp194, f"tmp196": tmp196, f"tmp197": tmp197, f"tmp199": tmp199, f"tmp2": tmp2, f"tmp201": tmp201, f"tmp203": tmp203, f"tmp204": tmp204, f"tmp205": tmp205, f"tmp206": tmp206, f"tmp207": tmp207, f"tmp209": tmp209, f"tmp21": tmp21, f"tmp210": tmp210, f"tmp211": tmp211, f"tmp212": tmp212, f"tmp214": tmp214, f"tmp215": tmp215, f"tmp22": tmp22, f"tmp223": tmp223, f"tmp225": tmp225, f"tmp230": tmp230, f"tmp232": tmp232, f"tmp238": tmp238, f"tmp240": tmp240, f"tmp247": tmp247, f"tmp248": tmp248, f"tmp25": tmp25, f"tmp250": tmp250, f"tmp251": tmp251, f"tmp253": tmp253, f"tmp254": tmp254, f"tmp256": tmp256, f"tmp26": tmp26, f"tmp262": tmp262, f"tmp264": tmp264, f"tmp27": tmp27, f"tmp275": tmp275, f"tmp277": tmp277, f"tmp279": tmp279, f"tmp28": tmp28, f"tmp281": tmp281, f"tmp283": tmp283, f"tmp285": tmp285, f"tmp291": tmp291, f"tmp292": tmp292, f"tmp294": tmp294, f"tmp295": tmp295, f"tmp297": tmp297, f"tmp299": tmp299, f"tmp30": tmp30, f"tmp301": tmp301, f"tmp306": tmp306, f"tmp307": tmp307, f"tmp309": tmp309, f"tmp314": tmp314, f"tmp315": tmp315, f"tmp317": tmp317, f"tmp319": tmp319, f"tmp32": tmp32, f"tmp320": tmp320, f"tmp324": tmp324, f"tmp325": tmp325, f"tmp327": tmp327, f"tmp328": tmp328, f"tmp333": tmp333, f"tmp334": tmp334, f"tmp336": tmp336, f"tmp34": tmp34, f"tmp346": tmp346, f"tmp349": tmp349, f"tmp351": tmp351, f"tmp353": tmp353, f"tmp355": tmp355, f"tmp357": tmp357, f"tmp359": tmp359, f"tmp36": tmp36, f"tmp361": tmp361, f"tmp37": tmp37, f"tmp38": tmp38, f"tmp39": tmp39, f"tmp391": tmp391, f"tmp393": tmp393, f"tmp4": tmp4, f"tmp41": tmp41, f"tmp422": tmp422, f"tmp425": tmp425, f"tmp426": tmp426, f"tmp428": tmp428, f"tmp43": tmp43, f"tmp430": tmp430, f"tmp432": tmp432, f"tmp434": tmp434, f"tmp436": tmp436, f"tmp438": tmp438, f"tmp449": tmp449, f"tmp45": tmp45, f"tmp451": tmp451, f"tmp453": tmp453, f"tmp46": tmp46, f"tmp47": tmp47, f"tmp49": tmp49, f"tmp5": tmp5, f"tmp51": tmp51, f"tmp53": tmp53, f"tmp55": tmp55, f"tmp57": tmp57, f"tmp59": tmp59, f"tmp61": tmp61, f"tmp62": tmp62, f"tmp64": tmp64, f"tmp65": tmp65, f"tmp66": tmp66, f"tmp68": tmp68, f"tmp7": tmp7, f"tmp70": tmp70, f"tmp72": tmp72, f"tmp74": tmp74, f"tmp76": tmp76, f"tmp78": tmp78, f"tmp8": tmp8, f"tmp80": tmp80, f"tmp82": tmp82, f"tmp83": tmp83, f"tmp85": tmp85, f"tmp86": tmp86, f"tmp88": tmp88, f"tmp89": tmp89, f"tmp90": tmp90, f"tmp92": tmp92, f"tmp94": tmp94, f"tmp96": tmp96, f"tmp98": tmp98} + +def hbar_lmatvec_ip(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:23:01.304389. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + r1 : Namespace of arrays + R1 amplitudes. + r2 : Namespace of arrays + R2 amplitudes. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + r1new : Namespace of arrays + Updated R1 residuals. + r2new : Namespace of arrays + Updated R2 residuals. + """ + + ints = kwargs["ints"] + r1new = Namespace() + r2new = Namespace() + tmp53 = einsum(t2.bbbb, (0, 1, 2, 3), r2.bbb, (0, 1, 3), (2,)) + tmp52 = einsum(r2.aba, (0, 1, 2), t2.abab, (0, 1, 2, 3), (3,)) + tmp87 = ints.tmp426.copy() + tmp87 += ints.tmp432 + tmp87 += ints.tmp436 * 2 + tmp91 = f.bb.oo.copy() + tmp91 += ints.tmp163 + tmp91 += ints.tmp167 + tmp91 += ints.tmp205 + tmp91 += ints.tmp209 + tmp91 += ints.tmp21.transpose((1, 0)) + tmp89 = ints.tmp425.copy() + tmp89 += ints.tmp430.transpose((0, 1, 3, 2)) * 2 + tmp62 = f.bb.ov.copy() + tmp62 += ints.tmp36 + tmp62 += ints.tmp38 + tmp62 += ints.tmp89 * -1 + tmp74 = ints.tmp324.copy() + tmp74 += ints.tmp434.transpose((0, 1, 3, 2)) * 2 + tmp74 += ints.tmp438.transpose((0, 1, 3, 2)) + tmp47 = einsum(r2.aba, (0, 1, 2), t1.aa, (3, 2), (0, 3, 1)) + tmp82 = ints.tmp140.copy() * 2 + tmp82 += ints.tmp143 + tmp82 += ints.tmp161 * -1 + tmp82 += ints.tmp203 * -1 + tmp49 = einsum(r2.bbb, (0, 1, 2), t1.bb, (3, 2), (0, 1, 3)) + tmp78 = v.bbbb.ooov.copy() + tmp78 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -1 + tmp76 = ints.tmp119.copy() * -1 + tmp76 += ints.tmp119.transpose((0, 2, 1, 3)) + tmp80 = tmp52.copy() * -0.5 + tmp80 += tmp53 + tmp40 = f.aa.ov.copy() + tmp40 += ints.tmp32 + tmp40 += ints.tmp39 + tmp40 += ints.tmp82 * -1 + tmp11 = einsum(r2.bab, (0, 1, 2), t1.bb, (3, 2), (1, 0, 3)) * -1 + tmp25 = ints.tmp47.copy() * 2 + tmp25 += ints.tmp49 + tmp25 += ints.tmp154 * -1 + tmp25 += ints.tmp25 * -1 + tmp20 = einsum(t1.aa, (0, 1), r2.aaa, (2, 3, 1), (2, 3, 0)) + tmp23 = v.aaaa.ooov.copy() * -1 + tmp23 += v.aaaa.ooov.transpose((0, 2, 1, 3)) + tmp21 = ints.tmp41.copy() * -1 + tmp21 += ints.tmp41.transpose((0, 2, 1, 3)) + tmp18 = ints.tmp349.copy() + tmp18 += ints.tmp357 + tmp18 += ints.tmp361 * 2 + tmp14 = einsum(t2.aaaa, (0, 1, 2, 3), r2.aaa, (0, 1, 3), (2,)) + tmp16 = ints.tmp193.copy() + tmp16 += ints.tmp355.transpose((0, 1, 3, 2)) * 2 + tmp16 += ints.tmp359.transpose((0, 1, 3, 2)) + tmp36 = f.aa.oo.copy() + tmp36 += ints.tmp155 + tmp36 += ints.tmp156 + tmp36 += ints.tmp1.transpose((1, 0)) + tmp36 += ints.tmp26 + tmp36 += ints.tmp27 + tmp32 = einsum(r2.bab, (0, 1, 2), t2.abab, (1, 0, 3, 2), (3,)) * -1 + tmp34 = ints.tmp346.copy() + tmp34 += ints.tmp351.transpose((0, 1, 3, 2)) * 2 + tmp88 = einsum(r2.aba, (0, 1, 2), tmp87, (0, 3, 2, 4), (1, 3, 4)) + del tmp87 + tmp92 = einsum(r2.bbb, (0, 1, 2), tmp91, (1, 3), (0, 3, 2)) * -1 + del tmp91 + tmp85 = einsum(ints.tmp119, (0, 1, 2, 3), r1.b, (0,), (1, 2, 3)) + tmp90 = einsum(tmp89, (0, 1, 2, 3), r2.bbb, (4, 0, 3), (4, 1, 2)) * -1 + del tmp89 + tmp86 = einsum(r2.bbb, (0, 1, 2), v.bbbb.ovov, (3, 4, 1, 2), (0, 3, 4)) + tmp63 = einsum(t1.bb, (0, 1), tmp62, (0, 2), (1, 2)) + tmp75 = einsum(tmp74, (0, 1, 2, 3), r2.bbb, (4, 0, 3), (4, 1, 2)) * -2 + del tmp74 + tmp70 = einsum(ints.tmp314, (0, 1, 2, 3), r2.bbb, (0, 1, 4), (2, 3, 4)) + tmp71 = einsum(r2.bbb, (0, 1, 2), v.bbbb.oovv, (3, 1, 4, 2), (0, 3, 4)) + tmp73 = einsum(tmp47, (0, 1, 2), v.aabb.ooov, (1, 0, 3, 4), (2, 3, 4)) + tmp83 = einsum(r2.bbb, (0, 1, 2), tmp82, (1, 3), (0, 3, 2)) * -2 + del tmp82 + tmp79 = einsum(tmp78, (0, 1, 2, 3), tmp49, (0, 4, 2), (4, 1, 3)) * 2 + del tmp78 + tmp77 = einsum(tmp76, (0, 1, 2, 3), tmp49, (0, 4, 1), (4, 2, 3)) * 2 + del tmp76 + tmp68 = einsum(r2.aba, (0, 1, 2), ints.tmp428, (0, 3, 2, 4), (3, 1, 4)) + tmp67 = einsum(r1.b, (0,), v.bbbb.ooov, (1, 0, 2, 3), (1, 2, 3)) + tmp72 = einsum(tmp47, (0, 1, 2), ints.tmp45, (0, 1, 3, 4), (3, 2, 4)) + tmp81 = einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp80, (1,), (0, 2, 3)) * 2 + del tmp80 + tmp69 = einsum(r2.aba, (0, 1, 2), v.aabb.ovov, (0, 2, 3, 4), (1, 3, 4)) + tmp41 = einsum(t1.aa, (0, 1), tmp40, (0, 2), (1, 2)) + tmp12 = einsum(v.aabb.ovoo, (0, 1, 2, 3), tmp11, (4, 3, 2), (4, 0, 1)) + tmp10 = einsum(v.aaaa.oovv, (0, 1, 2, 3), r2.aaa, (4, 1, 3), (4, 0, 2)) + tmp26 = einsum(tmp25, (0, 1), r2.aaa, (2, 0, 3), (2, 1, 3)) * -2 + del tmp25 + tmp24 = einsum(tmp23, (0, 1, 2, 3), tmp20, (0, 4, 1), (4, 2, 3)) * 2 + del tmp23 + tmp22 = einsum(tmp21, (0, 1, 2, 3), tmp20, (0, 4, 1), (4, 2, 3)) * 2 + del tmp21 + tmp19 = einsum(r2.bab, (0, 1, 2), tmp18, (3, 0, 4, 2), (1, 3, 4)) * -1 + del tmp18 + tmp15 = einsum(v.aaaa.ovov, (0, 1, 2, 3), tmp14, (3,), (0, 2, 1)) * -1 + tmp13 = einsum(tmp11, (0, 1, 2), ints.tmp124, (3, 1, 2, 4), (3, 0, 4)) + tmp17 = einsum(r2.aaa, (0, 1, 2), tmp16, (1, 3, 4, 2), (0, 3, 4)) * -2 + del tmp16 + tmp8 = einsum(v.aaaa.ooov, (0, 1, 2, 3), r1.a, (1,), (0, 2, 3)) + tmp9 = einsum(r2.aaa, (0, 1, 2), ints.tmp169, (1, 0, 3, 4), (3, 4, 2)) * -1 + tmp31 = einsum(r2.bab, (0, 1, 2), v.aabb.ovov, (3, 4, 0, 2), (1, 3, 4)) * -1 + tmp30 = einsum(r2.bab, (0, 1, 2), ints.tmp353, (3, 0, 4, 2), (3, 1, 4)) * -1 + tmp29 = einsum(v.aaaa.ovov, (0, 1, 2, 3), r2.aaa, (4, 2, 3), (4, 0, 1)) + tmp37 = einsum(r2.aaa, (0, 1, 2), tmp36, (1, 3), (0, 3, 2)) * -1 + del tmp36 + tmp33 = einsum(tmp32, (0,), v.aaaa.ovov, (1, 2, 3, 0), (1, 3, 2)) + tmp35 = einsum(r2.aaa, (0, 1, 2), tmp34, (1, 3, 4, 2), (0, 3, 4)) * -1 + del tmp34 + tmp28 = einsum(r1.a, (0,), ints.tmp41, (0, 1, 2, 3), (1, 2, 3)) + tmp93 = tmp85.copy() + del tmp85 + tmp93 += tmp86 * 2 + del tmp86 + tmp93 += tmp88.transpose((1, 0, 2)) + del tmp88 + tmp93 += tmp90.transpose((1, 0, 2)) * -2 + del tmp90 + tmp93 += tmp92.transpose((1, 0, 2)) * -2 + del tmp92 + tmp64 = ints.tmp186.transpose((1, 0)).copy() + tmp64 += ints.tmp449 * 2 + tmp64 += ints.tmp451 + tmp64 += f.bb.vv * -1 + tmp64 += ints.tmp184 * -1 + tmp64 += ints.tmp188 * -1 + tmp64 += tmp63 + del tmp63 + tmp94 = ints.tmp306.copy() + tmp94 += ints.tmp333 + tmp94 += v.bbbb.oooo.transpose((0, 2, 3, 1)) * -1 + tmp84 = tmp67.copy() + del tmp67 + tmp84 += tmp68 + del tmp68 + tmp84 += tmp69 + del tmp69 + tmp84 += tmp70 * 2 + del tmp70 + tmp84 += tmp71 * 2 + del tmp71 + tmp84 += tmp72 + del tmp72 + tmp84 += tmp73 * -1 + del tmp73 + tmp84 += tmp75.transpose((1, 0, 2)) * -1 + del tmp75 + tmp84 += tmp77.transpose((1, 0, 2)) + del tmp77 + tmp84 += tmp79 + del tmp79 + tmp84 += tmp81.transpose((1, 0, 2)) * -1 + del tmp81 + tmp84 += tmp83.transpose((1, 0, 2)) + del tmp83 + tmp56 = ints.tmp426.copy() + tmp56 += ints.tmp432 + tmp56 += ints.tmp436 * 2 + tmp56 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp56 += ints.tmp428 * -1 + tmp60 = ints.tmp45.copy() + tmp60 += v.aabb.ooov + tmp66 = tmp14.copy() + del tmp14 + tmp66 += tmp32 * 0.5 + del tmp32 + tmp61 = ints.tmp45.copy() + tmp61 += v.aabb.ooov + tmp58 = ints.tmp151.copy() + tmp58 += ints.tmp174 + tmp58 += ints.tmp176.transpose((1, 0, 2, 3)) + tmp58 += ints.tmp214 + tmp58 += v.aabb.oooo + tmp55 = ints.tmp324.copy() + tmp55 += ints.tmp434.transpose((0, 1, 3, 2)) * 2 + tmp55 += ints.tmp438.transpose((0, 1, 3, 2)) + tmp55 += v.bbbb.ovov.transpose((0, 2, 3, 1)) + tmp55 += ints.tmp425 * -1 + tmp55 += ints.tmp430.transpose((0, 1, 3, 2)) * -2 + tmp55 += v.bbbb.oovv * -1 + tmp65 = f.bb.oo.copy() + tmp65 += ints.tmp140 * 2 + tmp65 += ints.tmp143 + tmp65 += ints.tmp163 + tmp65 += ints.tmp167 + tmp65 += ints.tmp205 + tmp65 += ints.tmp209 + tmp65 += ints.tmp21.transpose((1, 0)) + tmp65 += ints.tmp161 * -1 + tmp65 += ints.tmp203 * -1 + tmp57 = ints.tmp196.copy() + tmp57 += v.aabb.oovv + tmp57 += ints.tmp453 * -1 + tmp59 = ints.tmp119.copy() * -1 + tmp59 += ints.tmp119.transpose((0, 2, 1, 3)) + tmp59 += v.bbbb.ooov + tmp59 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -1 + tmp4 = f.aa.oo.copy() + tmp4 += ints.tmp155 + tmp4 += ints.tmp156 + tmp4 += ints.tmp1.transpose((1, 0)) + tmp4 += ints.tmp26.transpose((1, 0)) + tmp4 += ints.tmp27.transpose((1, 0)) + tmp4 += ints.tmp47 * 2 + tmp4 += ints.tmp49 + tmp4 += ints.tmp154 * -1 + tmp4 += ints.tmp25 * -1 + tmp45 = ints.tmp327.copy() + tmp45 += v.aabb.vvoo.transpose((2, 3, 0, 1)) + tmp45 += ints.tmp422 * -1 + tmp50 = ints.tmp124.copy() + tmp50 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp51 = f.aa.oo.copy() + tmp51 += ints.tmp155 + tmp51 += ints.tmp156 + tmp51 += ints.tmp1.transpose((1, 0)) + tmp51 += ints.tmp26 + tmp51 += ints.tmp27 + tmp51 += ints.tmp47 * 2 + tmp51 += ints.tmp49 + tmp51 += ints.tmp154 * -1 + tmp51 += ints.tmp25 * -1 + tmp7 = f.bb.oo.copy() + tmp7 += ints.tmp140 * 2 + tmp7 += ints.tmp143 + tmp7 += ints.tmp163.transpose((1, 0)) + tmp7 += ints.tmp167.transpose((1, 0)) + tmp7 += ints.tmp205 + tmp7 += ints.tmp209 + tmp7 += ints.tmp21.transpose((1, 0)) + tmp7 += ints.tmp161 * -1 + tmp7 += ints.tmp203 * -1 + tmp48 = ints.tmp41.copy() * -1 + tmp48 += ints.tmp41.transpose((0, 2, 1, 3)) + tmp48 += v.aaaa.ooov + tmp48 += v.aaaa.ooov.transpose((0, 2, 1, 3)) * -1 + tmp44 = ints.tmp349.copy() + tmp44 += ints.tmp357 + tmp44 += ints.tmp361 * 2 + tmp44 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp44 += ints.tmp353 * -1 + tmp42 = ints.tmp181.transpose((1, 0)).copy() + tmp42 += ints.tmp391 * 2 + tmp42 += ints.tmp393 + tmp42 += f.aa.vv * -1 + tmp42 += ints.tmp178 * -1 + tmp42 += ints.tmp190 * -1 + tmp42 += tmp41 + del tmp41 + tmp46 = ints.tmp151.copy() + tmp46 += ints.tmp174.transpose((0, 1, 3, 2)) + tmp46 += ints.tmp176 + tmp46 += ints.tmp214 + tmp46 += v.aabb.oooo + tmp43 = ints.tmp193.copy() + tmp43 += ints.tmp355.transpose((0, 1, 3, 2)) * 2 + tmp43 += ints.tmp359.transpose((0, 1, 3, 2)) + tmp43 += v.aaaa.ovov.transpose((0, 2, 3, 1)) + tmp43 += ints.tmp346 * -1 + tmp43 += ints.tmp351.transpose((0, 1, 3, 2)) * -2 + tmp43 += v.aaaa.oovv * -1 + tmp54 = tmp52.copy() * -1 + del tmp52 + tmp54 += tmp53 * 2 + del tmp53 + tmp27 = tmp8.copy() + del tmp8 + tmp27 += tmp9 * 2 + del tmp9 + tmp27 += tmp10 * 2 + del tmp10 + tmp27 += tmp12 + del tmp12 + tmp27 += tmp13 * -1 + del tmp13 + tmp27 += tmp15 * 2 + del tmp15 + tmp27 += tmp17.transpose((1, 0, 2)) * -1 + del tmp17 + tmp27 += tmp19.transpose((1, 0, 2)) + del tmp19 + tmp27 += tmp22.transpose((1, 0, 2)) + del tmp22 + tmp27 += tmp24 + del tmp24 + tmp27 += tmp26.transpose((1, 0, 2)) + del tmp26 + tmp38 = tmp28.copy() + del tmp28 + tmp38 += tmp29 * 2 + del tmp29 + tmp38 += tmp30 + del tmp30 + tmp38 += tmp31 + del tmp31 + tmp38 += tmp33 + del tmp33 + tmp38 += tmp35.transpose((1, 0, 2)) * -2 + del tmp35 + tmp38 += tmp37.transpose((1, 0, 2)) * -2 + del tmp37 + tmp39 = ints.tmp148.copy() + tmp39 += ints.tmp211 + tmp39 += v.aaaa.oooo.transpose((0, 2, 3, 1)) * -1 + tmp6 = ints.tmp225.transpose((1, 2, 0, 3)).copy() * 0.5 + tmp6 += ints.tmp230.transpose((1, 2, 0, 3)) * 0.5 + tmp6 += ints.tmp238.transpose((0, 2, 1, 3)) * 0.5 + tmp6 += ints.tmp251.transpose((0, 2, 1, 3)) + tmp6 += ints.tmp256.transpose((0, 2, 1, 3)) * 0.5 + tmp6 += ints.tmp281 * 0.5 + tmp6 += ints.tmp285 * 0.5 + tmp6 += ints.tmp295 + tmp6 += ints.tmp307 * 0.5 + tmp6 += ints.tmp315 * 0.5 + tmp6 += ints.tmp334 * 0.5 + tmp6 += ints.tmp119 * -0.5 + tmp6 += ints.tmp248 * -1 + tmp6 += ints.tmp262 * -0.5 + tmp6 += ints.tmp277 * -0.5 + tmp6 += ints.tmp292 * -1 + tmp6 += ints.tmp299 * -0.5 + tmp6 += ints.tmp317.transpose((0, 2, 1, 3)) * -0.5 + tmp6 += ints.tmp325 * -0.5 + tmp6 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -0.5 + tmp3 = ints.tmp117.copy() + tmp3 += ints.tmp122 * 0.5 + tmp3 += ints.tmp138 + tmp3 += ints.tmp146 * 0.5 + tmp3 += ints.tmp159 * 0.5 + tmp3 += ints.tmp165 * 0.5 + tmp3 += ints.tmp182 * 0.5 + tmp3 += ints.tmp19 * 0.5 + tmp3 += ints.tmp201 * 0.5 + tmp3 += ints.tmp207 * 0.5 + tmp3 += ints.tmp2 * 0.5 + tmp3 += ints.tmp34 * 0.5 + tmp3 += ints.tmp51 + tmp3 += ints.tmp57 * 0.5 + tmp3 += ints.tmp70 + tmp3 += ints.tmp83 + tmp3 += ints.tmp90 * 0.5 + tmp3 += f.aa.ov * -0.5 + tmp3 += ints.tmp101 * -0.5 + tmp3 += ints.tmp11 * -0.5 + tmp3 += ints.tmp157 * -0.5 + tmp3 += ints.tmp179 * -0.5 + tmp3 += ints.tmp191 * -0.5 + tmp3 += ints.tmp199 * -0.5 + tmp3 += ints.tmp32 * -0.5 + tmp3 += ints.tmp39 * -0.5 + tmp3 += ints.tmp5 * -0.5 + tmp3 += ints.tmp76 * -0.5 + tmp3 += ints.tmp86 * -1 + tmp3 += ints.tmp8 * -1 + tmp3 += ints.tmp94 * -0.5 + tmp3 += ints.tmp98 * -1 + tmp5 = ints.tmp124.copy() + tmp5 += ints.tmp223.transpose((0, 2, 1, 3)) + tmp5 += ints.tmp240.transpose((0, 2, 1, 3)) + tmp5 += ints.tmp250.transpose((0, 2, 1, 3)) + tmp5 += ints.tmp254.transpose((0, 2, 1, 3)) * 2 + tmp5 += ints.tmp264 + tmp5 += ints.tmp279 + tmp5 += ints.tmp283 + tmp5 += ints.tmp291 + tmp5 += ints.tmp297 * 2 + tmp5 += ints.tmp328 + tmp5 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp5 += ints.tmp232.transpose((0, 2, 1, 3)) * -1 + tmp5 += ints.tmp247 * -1 + tmp5 += ints.tmp253 * -1 + tmp5 += ints.tmp275 * -1 + tmp5 += ints.tmp294 * -1 + tmp5 += ints.tmp301 * -1 + tmp5 += ints.tmp309 * -1 + tmp5 += ints.tmp319 * -1 + tmp5 += ints.tmp320.transpose((0, 2, 1, 3)) * -1 + tmp5 += ints.tmp336 * -1 + tmp2 = ints.tmp120.copy() + tmp2 += ints.tmp125 * 0.5 + tmp2 += ints.tmp141 + tmp2 += ints.tmp144 * 0.5 + tmp2 += ints.tmp164 * 0.5 + tmp2 += ints.tmp168 * 0.5 + tmp2 += ints.tmp187 * 0.5 + tmp2 += ints.tmp206 * 0.5 + tmp2 += ints.tmp210 * 0.5 + tmp2 += ints.tmp22 * 0.5 + tmp2 += ints.tmp37 * 0.5 + tmp2 += ints.tmp4 * 0.5 + tmp2 += ints.tmp53 + tmp2 += ints.tmp55 * 0.5 + tmp2 += ints.tmp72 + tmp2 += ints.tmp85 * 0.5 + tmp2 += ints.tmp92 + tmp2 += f.bb.ov * -0.5 + tmp2 += ints.tmp100 * -0.5 + tmp2 += ints.tmp103 * -1 + tmp2 += ints.tmp10 * -0.5 + tmp2 += ints.tmp13 * -1 + tmp2 += ints.tmp162 * -0.5 + tmp2 += ints.tmp185 * -0.5 + tmp2 += ints.tmp189 * -0.5 + tmp2 += ints.tmp204 * -0.5 + tmp2 += ints.tmp36 * -0.5 + tmp2 += ints.tmp38 * -0.5 + tmp2 += ints.tmp74 * -0.5 + tmp2 += ints.tmp7 * -0.5 + tmp2 += ints.tmp88 * -0.5 + tmp2 += ints.tmp96 * -1 + tmp1 = ints.tmp109.copy() * 0.5 + tmp1 += ints.tmp113 * 0.5 + tmp1 += ints.tmp130 + tmp1 += ints.tmp149 * 0.5 + tmp1 += ints.tmp15.transpose((1, 2, 0, 3)) * 0.5 + tmp1 += ints.tmp170 * 0.5 + tmp1 += ints.tmp212 * 0.5 + tmp1 += ints.tmp28.transpose((1, 2, 0, 3)) * 0.5 + tmp1 += ints.tmp43.transpose((0, 2, 1, 3)) * 0.5 + tmp1 += ints.tmp62.transpose((0, 2, 1, 3)) + tmp1 += ints.tmp66.transpose((0, 2, 1, 3)) * 0.5 + tmp1 += ints.tmp105 * -0.5 + tmp1 += ints.tmp127 * -1 + tmp1 += ints.tmp133 * -0.5 + tmp1 += ints.tmp172.transpose((0, 2, 1, 3)) * -0.5 + tmp1 += ints.tmp194 * -0.5 + tmp1 += ints.tmp41 * -0.5 + tmp1 += ints.tmp59 * -1 + tmp1 += ints.tmp78 * -0.5 + tmp1 += v.aaaa.ooov.transpose((0, 2, 1, 3)) * -0.5 + tmp0 = ints.tmp111.copy() + tmp0 += ints.tmp115 + tmp0 += ints.tmp129 + tmp0 += ints.tmp135 * 2 + tmp0 += ints.tmp17.transpose((1, 0, 2, 3)) + tmp0 += ints.tmp197 + tmp0 += ints.tmp45 + tmp0 += ints.tmp46.transpose((1, 0, 2, 3)) + tmp0 += ints.tmp64.transpose((1, 0, 2, 3)) + tmp0 += ints.tmp68.transpose((1, 0, 2, 3)) * 2 + tmp0 += ints.tmp80 + tmp0 += v.aabb.ooov + tmp0 += ints.tmp107 * -1 + tmp0 += ints.tmp132 * -1 + tmp0 += ints.tmp137 * -1 + tmp0 += ints.tmp152 * -1 + tmp0 += ints.tmp175 * -1 + tmp0 += ints.tmp177.transpose((1, 0, 2, 3)) * -1 + tmp0 += ints.tmp215 * -1 + tmp0 += ints.tmp30.transpose((1, 0, 2, 3)) * -1 + tmp0 += ints.tmp61 * -1 + tmp0 += ints.tmp65 * -1 + r2new.bbb = tmp84.copy() * -1 + r2new.bbb += tmp84.transpose((1, 0, 2)) + del tmp84 + r2new.bbb += tmp93 + r2new.bbb += tmp93.transpose((1, 0, 2)) * -1 + del tmp93 + r2new.bbb += einsum(tmp94, (0, 1, 2, 3), r2.bbb, (1, 0, 4), (2, 3, 4)) * -2 + del tmp94 + r2new.bbb += einsum(tmp64, (0, 1), r2.bbb, (2, 3, 0), (2, 3, 1)) * -2 + r2new.bbb += einsum(r1.b, (0,), tmp62, (1, 2), (0, 1, 2)) + r2new.bbb += einsum(tmp62, (0, 1), r1.b, (2,), (0, 2, 1)) * -1 + r2new.bab = einsum(tmp55, (0, 1, 2, 3), r2.bab, (0, 4, 3), (1, 4, 2)) + del tmp55 + r2new.bab += einsum(tmp56, (0, 1, 2, 3), r2.aaa, (4, 0, 2), (1, 4, 3)) * -2 + del tmp56 + r2new.bab += einsum(r2.bab, (0, 1, 2), tmp57, (1, 3, 2, 4), (0, 3, 4)) * -1 + del tmp57 + r2new.bab += einsum(tmp58, (0, 1, 2, 3), r2.bab, (2, 0, 4), (3, 1, 4)) + del tmp58 + r2new.bab += einsum(tmp59, (0, 1, 2, 3), tmp11, (4, 0, 1), (2, 4, 3)) + del tmp59 + r2new.bab += einsum(tmp11, (0, 1, 2), tmp60, (0, 3, 2, 4), (1, 3, 4)) * -1 + del tmp11, tmp60 + r2new.bab += einsum(tmp61, (0, 1, 2, 3), tmp20, (0, 4, 1), (2, 4, 3)) * -2 + del tmp20 + r2new.bab += einsum(tmp64, (0, 1), r2.bab, (2, 3, 0), (2, 3, 1)) * -1 + del tmp64 + r2new.bab += einsum(r2.bab, (0, 1, 2), tmp65, (0, 3), (3, 1, 2)) * -1 + del tmp65 + r2new.bab += einsum(tmp4, (0, 1), r2.bab, (2, 0, 3), (2, 1, 3)) * -1 + r2new.bab += einsum(tmp66, (0,), v.aabb.ovov, (1, 0, 2, 3), (2, 1, 3)) * 2 + del tmp66 + r2new.bab += einsum(tmp61, (0, 1, 2, 3), r1.a, (0,), (2, 1, 3)) + del tmp61 + r2new.bab += einsum(tmp62, (0, 1), r1.a, (2,), (0, 2, 1)) * -1 + del tmp62 + r2new.aba = einsum(r2.aba, (0, 1, 2), tmp43, (0, 3, 4, 2), (3, 1, 4)) + del tmp43 + r2new.aba += einsum(r2.bbb, (0, 1, 2), tmp44, (3, 1, 4, 2), (3, 0, 4)) * -2 + del tmp44 + r2new.aba += einsum(r2.aba, (0, 1, 2), tmp45, (1, 3, 2, 4), (0, 3, 4)) * -1 + del tmp45 + r2new.aba += einsum(tmp46, (0, 1, 2, 3), r2.aba, (0, 2, 4), (1, 3, 4)) + del tmp46 + r2new.aba += einsum(tmp48, (0, 1, 2, 3), tmp47, (0, 1, 4), (2, 4, 3)) * -1 + del tmp48 + r2new.aba += einsum(tmp49, (0, 1, 2), tmp50, (3, 0, 2, 4), (3, 1, 4)) * -2 + del tmp49 + r2new.aba += einsum(tmp47, (0, 1, 2), tmp50, (1, 2, 3, 4), (0, 3, 4)) + del tmp47 + r2new.aba += einsum(r2.aba, (0, 1, 2), tmp42, (2, 3), (0, 1, 3)) * -1 + r2new.aba += einsum(tmp7, (0, 1), r2.aba, (2, 0, 3), (2, 1, 3)) * -1 + r2new.aba += einsum(tmp51, (0, 1), r2.aba, (0, 2, 3), (1, 2, 3)) * -1 + del tmp51 + r2new.aba += einsum(v.aabb.ovov, (0, 1, 2, 3), tmp54, (3,), (0, 2, 1)) + del tmp54 + r2new.aba += einsum(tmp50, (0, 1, 2, 3), r1.b, (1,), (0, 2, 3)) + del tmp50 + r2new.aba += einsum(r1.b, (0,), tmp40, (1, 2), (1, 0, 2)) * -1 + r2new.aaa = tmp27.copy() * -1 + r2new.aaa += tmp27.transpose((1, 0, 2)) + del tmp27 + r2new.aaa += tmp38 + r2new.aaa += tmp38.transpose((1, 0, 2)) * -1 + del tmp38 + r2new.aaa += einsum(r2.aaa, (0, 1, 2), tmp39, (0, 1, 3, 4), (3, 4, 2)) * 2 + del tmp39 + r2new.aaa += einsum(tmp42, (0, 1), r2.aaa, (2, 3, 0), (2, 3, 1)) * -2 + del tmp42 + r2new.aaa += einsum(r1.a, (0,), tmp40, (1, 2), (0, 1, 2)) + r2new.aaa += einsum(tmp40, (0, 1), r1.a, (2,), (0, 2, 1)) * -1 + del tmp40 + r1new.b = einsum(r2.aba, (0, 1, 2), tmp5, (0, 1, 3, 2), (3,)) + del tmp5 + r1new.b += einsum(r2.bbb, (0, 1, 2), tmp6, (1, 0, 3, 2), (3,)) * -4 + del tmp6 + r1new.b += einsum(r2.bbb, (0, 1, 2), tmp2, (1, 2), (0,)) * -4 + r1new.b += einsum(r2.aba, (0, 1, 2), tmp3, (0, 2), (1,)) * 2 + r1new.b += einsum(tmp7, (0, 1), r1.b, (0,), (1,)) * -1 + del tmp7 + r1new.a = einsum(r2.bab, (0, 1, 2), tmp0, (1, 3, 0, 2), (3,)) + del tmp0 + r1new.a += einsum(r2.aaa, (0, 1, 2), tmp1, (1, 0, 3, 2), (3,)) * -4 + del tmp1 + r1new.a += einsum(r2.bab, (0, 1, 2), tmp2, (0, 2), (1,)) * 2 + del tmp2 + r1new.a += einsum(r2.aaa, (0, 1, 2), tmp3, (1, 2), (0,)) * -4 + del tmp3 + r1new.a += einsum(tmp4, (0, 1), r1.a, (0,), (1,)) * -1 + del tmp4 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ea_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:25:19.852199. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + tmp10 : array + tmp100 : array + tmp101 : array + tmp103 : array + tmp11 : array + tmp111 : array + tmp112 : array + tmp114 : array + tmp115 : array + tmp117 : array + tmp118 : array + tmp120 : array + tmp121 : array + tmp123 : array + tmp125 : array + tmp127 : array + tmp128 : array + tmp13 : array + tmp130 : array + tmp131 : array + tmp133 : array + tmp134 : array + tmp136 : array + tmp137 : array + tmp139 : array + tmp141 : array + tmp142 : array + tmp144 : array + tmp145 : array + tmp147 : array + tmp149 : array + tmp150 : array + tmp151 : array + tmp153 : array + tmp154 : array + tmp156 : array + tmp157 : array + tmp158 : array + tmp159 : array + tmp160 : array + tmp161 : array + tmp163 : array + tmp164 : array + tmp169 : array + tmp171 : array + tmp173 : array + tmp174 : array + tmp175 : array + tmp176 : array + tmp177 : array + tmp178 : array + tmp179 : array + tmp181 : array + tmp183 : array + tmp185 : array + tmp186 : array + tmp187 : array + tmp188 : array + tmp19 : array + tmp190 : array + tmp191 : array + tmp193 : array + tmp194 : array + tmp195 : array + tmp196 : array + tmp197 : array + tmp198 : array + tmp2 : array + tmp20 : array + tmp200 : array + tmp201 : array + tmp22 : array + tmp226 : array + tmp228 : array + tmp23 : array + tmp230 : array + tmp232 : array + tmp238 : array + tmp240 : array + tmp246 : array + tmp247 : array + tmp249 : array + tmp250 : array + tmp252 : array + tmp254 : array + tmp256 : array + tmp26 : array + tmp27 : array + tmp276 : array + tmp278 : array + tmp28 : array + tmp284 : array + tmp285 : array + tmp287 : array + tmp288 : array + tmp29 : array + tmp290 : array + tmp292 : array + tmp294 : array + tmp305 : array + tmp307 : array + tmp309 : array + tmp31 : array + tmp310 : array + tmp33 : array + tmp34 : array + tmp35 : array + tmp36 : array + tmp4 : array + tmp43 : array + tmp45 : array + tmp47 : array + tmp49 : array + tmp5 : array + tmp51 : array + tmp53 : array + tmp55 : array + tmp57 : array + tmp59 : array + tmp61 : array + tmp63 : array + tmp65 : array + tmp67 : array + tmp69 : array + tmp7 : array + tmp71 : array + tmp73 : array + tmp74 : array + tmp76 : array + tmp77 : array + tmp79 : array + tmp8 : array + tmp81 : array + tmp82 : array + tmp83 : array + tmp85 : array + tmp86 : array + tmp88 : array + tmp89 : array + tmp90 : array + tmp92 : array + tmp94 : array + tmp96 : array + tmp98 : array + """ + + tmp35 = einsum(t1.aa, (0, 1), v.aabb.ovov, (0, 1, 2, 3), (2, 3)) + tmp36 = einsum(t1.bb, (0, 1), v.aabb.ovov, (2, 3, 0, 1), (2, 3)) + tmp33 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 0, 1), (2, 3)) + tmp89 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 1, 0, 3), (2, 3)) + tmp29 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 3, 0, 1), (2, 3)) + tmp82 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 1, 0, 3), (2, 3)) + tmp117 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 0, 2, 3)) + tmp114 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp200 = einsum(t1.bb, (0, 1), tmp35, (2, 1), (0, 2)) + tmp197 = einsum(t1.aa, (0, 1), tmp36, (2, 1), (0, 2)) + tmp195 = einsum(t1.bb, (0, 1), tmp33, (2, 1), (0, 2)) + tmp193 = einsum(tmp89, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp190 = einsum(t1.aa, (0, 1), tmp29, (2, 1), (0, 2)) + tmp187 = einsum(tmp82, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp28 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp177 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.aa, (0, 1), (2, 3)) + tmp175 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 3), (1, 2)) + tmp173 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 1), (2, 3)) + tmp27 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 2, 3, 1), (2, 3)) + tmp26 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 1, 2, 3), (2, 3)) + tmp163 = einsum(t1.aa, (0, 1), v.aabb.ovoo, (0, 1, 2, 3), (2, 3)) + tmp160 = einsum(t1.bb, (0, 1), v.aabb.ooov, (2, 3, 0, 1), (2, 3)) + tmp158 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp156 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (1, 3), (0, 2)) + tmp153 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 3, 0, 1), (2, 3)) + tmp150 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 0, 3, 1), (2, 3)) + tmp136 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 3), (4, 0)) + tmp133 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp130 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 1, 3), (4, 0)) + tmp127 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (4, 3, 1, 2), (0, 4)) * -1 + tmp120 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 2, 1)) + tmp111 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t1.aa, (4, 3), (4, 0, 2, 1)) + tmp22 = einsum(t1.bb, (0, 1), f.bb.ov, (2, 1), (2, 0)) + tmp19 = einsum(f.aa.ov, (0, 1), t1.aa, (2, 1), (0, 2)) + tmp310 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 2, 0, 3)) + tmp309 = einsum(t1.aa, (0, 1), v.aabb.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp307 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp305 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 1), (4, 0, 2, 3)) + tmp294 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 5), (4, 0, 5, 3)) + tmp292 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 5, 3)) + tmp290 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 2, 5, 3)) + tmp288 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovov, (4, 3, 1, 5), (0, 4, 2, 5)) + tmp287 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp285 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp284 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovov, (4, 5, 1, 3), (0, 4, 2, 5)) + tmp278 = einsum(tmp117, (0, 1, 2, 3), t2.abab, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp276 = einsum(tmp114, (0, 1, 2, 3), t2.bbbb, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp256 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 1, 5), (0, 4, 3, 5)) + tmp254 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 5, 2, 3)) + tmp252 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 5, 2, 3)) + tmp250 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 5, 3), (4, 5, 1, 2)) + tmp249 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp247 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 5, 1), (4, 5, 2, 3)) + tmp246 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovvv, (1, 3, 4, 5), (0, 2, 4, 5)) + tmp240 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.abab, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp238 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp232 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 2, 1, 4), (4, 3)) + tmp230 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (0, 2, 4, 3), (4, 1)) + tmp228 = einsum(t1.aa, (0, 1), v.aabb.vvvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp226 = einsum(v.bbbb.vvvv, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp201 = einsum(t1.bb, (0, 1), tmp200, (2, 0), (2, 1)) + tmp198 = einsum(tmp197, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp196 = einsum(t1.bb, (0, 1), tmp195, (2, 0), (2, 1)) + tmp194 = einsum(t1.bb, (0, 1), tmp193, (2, 0), (2, 1)) + tmp191 = einsum(tmp190, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp188 = einsum(tmp187, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp186 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 1, 2)) + tmp185 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (4, 3), (4, 2, 0, 1)) + tmp183 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp181 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp179 = einsum(t1.aa, (0, 1), tmp28, (2, 1), (0, 2)) + tmp178 = einsum(tmp177, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp176 = einsum(t1.bb, (0, 1), tmp175, (1, 2), (0, 2)) + tmp174 = einsum(t1.bb, (0, 1), tmp173, (2, 1), (0, 2)) + tmp171 = einsum(tmp27, (0, 1), t1.aa, (2, 0), (2, 1)) + tmp169 = einsum(t1.aa, (0, 1), tmp26, (2, 1), (0, 2)) + tmp164 = einsum(t1.bb, (0, 1), tmp163, (2, 0), (2, 1)) + tmp161 = einsum(tmp160, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp159 = einsum(t1.bb, (0, 1), tmp158, (2, 0), (2, 1)) + tmp157 = einsum(tmp156, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp154 = einsum(tmp153, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp151 = einsum(tmp150, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp149 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 5, 3), (1, 5, 2, 4)) + tmp147 = einsum(t2.bbbb, (0, 1, 2, 3), v.aabb.ovov, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp145 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp144 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.abab, (2, 4, 1, 5), (0, 4, 3, 5)) + tmp142 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp141 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovov, (4, 5, 0, 2), (4, 1, 5, 3)) + tmp139 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp137 = einsum(tmp136, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp134 = einsum(t1.bb, (0, 1), tmp133, (2, 0), (2, 1)) + tmp131 = einsum(t1.bb, (0, 1), tmp130, (2, 0), (2, 1)) + tmp128 = einsum(tmp127, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp125 = einsum(t2.abab, (0, 1, 2, 3), tmp120, (0, 4, 1, 5), (4, 2, 5, 3)) + tmp123 = einsum(tmp111, (0, 1, 2, 3), t2.aaaa, (2, 1, 4, 5), (0, 4, 5, 3)) * -1 + tmp121 = einsum(tmp120, (0, 1, 2, 3), t2.abab, (0, 2, 3, 4), (1, 4)) + tmp118 = einsum(t2.abab, (0, 1, 2, 3), tmp117, (4, 0, 1, 3), (4, 2)) + tmp115 = einsum(tmp114, (0, 1, 2, 3), t2.bbbb, (2, 1, 4, 3), (0, 4)) + tmp112 = einsum(t2.aaaa, (0, 1, 2, 3), tmp111, (4, 0, 1, 3), (4, 2)) * -1 + tmp103 = einsum(t2.bbbb, (0, 1, 2, 3), tmp35, (1, 3), (0, 2)) + tmp101 = einsum(tmp35, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp100 = einsum(tmp36, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp98 = einsum(t2.aaaa, (0, 1, 2, 3), tmp36, (1, 3), (0, 2)) + tmp96 = einsum(t2.bbbb, (0, 1, 2, 3), tmp33, (1, 3), (0, 2)) + tmp94 = einsum(tmp33, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp92 = einsum(tmp89, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp90 = einsum(tmp89, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp88 = einsum(tmp29, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp86 = einsum(tmp29, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp85 = einsum(tmp82, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp83 = einsum(tmp82, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp81 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 5, 3), (4, 5, 1, 2)) + tmp79 = einsum(t2.bbbb, (0, 1, 2, 3), v.aabb.vvov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp77 = einsum(v.aabb.vvov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 5, 0, 1)) + tmp76 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovvv, (0, 4, 5, 2), (1, 4, 5, 3)) + tmp74 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp73 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 3, 5)) + tmp71 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 3, 4, 5), (0, 2, 4, 5)) + tmp69 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 1, 3), (0, 4)) + tmp67 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp65 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 1, 3), (4, 2)) + tmp63 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 3, 4, 2), (0, 4)) * -1 + tmp61 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovoo, (0, 4, 5, 1), (5, 2, 4, 3)) + tmp59 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ooov, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 + tmp57 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.abab, (1, 2, 4, 3), (0, 4)) + tmp55 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.abab, (0, 3, 1, 4), (2, 4)) + tmp53 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ooov, (4, 0, 1, 3), (4, 2)) + tmp51 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.aaaa, (2, 1, 4, 3), (0, 4)) * -1 + tmp49 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 1, 3), (2, 4)) + tmp47 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (0, 3, 1, 4), (2, 4)) * -1 + tmp45 = einsum(t1.bb, (0, 1), v.aabb.vvvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp43 = einsum(v.aaaa.vvvv, (0, 1, 2, 3), t1.aa, (4, 3), (4, 0, 1, 2)) + tmp34 = einsum(t1.bb, (0, 1), v.bbbb.oovv, (2, 0, 3, 1), (2, 3)) + tmp31 = einsum(t1.aa, (0, 1), v.aaaa.oovv, (2, 0, 3, 1), (2, 3)) + tmp23 = einsum(t1.bb, (0, 1), tmp22, (0, 2), (2, 1)) + tmp20 = einsum(tmp19, (0, 1), t1.aa, (0, 2), (1, 2)) + tmp13 = einsum(f.bb.ov, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp11 = einsum(f.bb.ov, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp10 = einsum(f.aa.ov, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp8 = einsum(f.aa.ov, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp7 = einsum(f.bb.vv, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp5 = einsum(f.aa.vv, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp4 = einsum(t1.bb, (0, 1), f.bb.oo, (2, 0), (2, 1)) + tmp2 = einsum(f.aa.oo, (0, 1), t1.aa, (1, 2), (0, 2)) + + return {f"tmp10": tmp10, f"tmp100": tmp100, f"tmp101": tmp101, f"tmp103": tmp103, f"tmp11": tmp11, f"tmp111": tmp111, f"tmp112": tmp112, f"tmp114": tmp114, f"tmp115": tmp115, f"tmp117": tmp117, f"tmp118": tmp118, f"tmp120": tmp120, f"tmp121": tmp121, f"tmp123": tmp123, f"tmp125": tmp125, f"tmp127": tmp127, f"tmp128": tmp128, f"tmp13": tmp13, f"tmp130": tmp130, f"tmp131": tmp131, f"tmp133": tmp133, f"tmp134": tmp134, f"tmp136": tmp136, f"tmp137": tmp137, f"tmp139": tmp139, f"tmp141": tmp141, f"tmp142": tmp142, f"tmp144": tmp144, f"tmp145": tmp145, f"tmp147": tmp147, f"tmp149": tmp149, f"tmp150": tmp150, f"tmp151": tmp151, f"tmp153": tmp153, f"tmp154": tmp154, f"tmp156": tmp156, f"tmp157": tmp157, f"tmp158": tmp158, f"tmp159": tmp159, f"tmp160": tmp160, f"tmp161": tmp161, f"tmp163": tmp163, f"tmp164": tmp164, f"tmp169": tmp169, f"tmp171": tmp171, f"tmp173": tmp173, f"tmp174": tmp174, f"tmp175": tmp175, f"tmp176": tmp176, f"tmp177": tmp177, f"tmp178": tmp178, f"tmp179": tmp179, f"tmp181": tmp181, f"tmp183": tmp183, f"tmp185": tmp185, f"tmp186": tmp186, f"tmp187": tmp187, f"tmp188": tmp188, f"tmp19": tmp19, f"tmp190": tmp190, f"tmp191": tmp191, f"tmp193": tmp193, f"tmp194": tmp194, f"tmp195": tmp195, f"tmp196": tmp196, f"tmp197": tmp197, f"tmp198": tmp198, f"tmp2": tmp2, f"tmp20": tmp20, f"tmp200": tmp200, f"tmp201": tmp201, f"tmp22": tmp22, f"tmp226": tmp226, f"tmp228": tmp228, f"tmp23": tmp23, f"tmp230": tmp230, f"tmp232": tmp232, f"tmp238": tmp238, f"tmp240": tmp240, f"tmp246": tmp246, f"tmp247": tmp247, f"tmp249": tmp249, f"tmp250": tmp250, f"tmp252": tmp252, f"tmp254": tmp254, f"tmp256": tmp256, f"tmp26": tmp26, f"tmp27": tmp27, f"tmp276": tmp276, f"tmp278": tmp278, f"tmp28": tmp28, f"tmp284": tmp284, f"tmp285": tmp285, f"tmp287": tmp287, f"tmp288": tmp288, f"tmp29": tmp29, f"tmp290": tmp290, f"tmp292": tmp292, f"tmp294": tmp294, f"tmp305": tmp305, f"tmp307": tmp307, f"tmp309": tmp309, f"tmp31": tmp31, f"tmp310": tmp310, f"tmp33": tmp33, f"tmp34": tmp34, f"tmp35": tmp35, f"tmp36": tmp36, f"tmp4": tmp4, f"tmp43": tmp43, f"tmp45": tmp45, f"tmp47": tmp47, f"tmp49": tmp49, f"tmp5": tmp5, f"tmp51": tmp51, f"tmp53": tmp53, f"tmp55": tmp55, f"tmp57": tmp57, f"tmp59": tmp59, f"tmp61": tmp61, f"tmp63": tmp63, f"tmp65": tmp65, f"tmp67": tmp67, f"tmp69": tmp69, f"tmp7": tmp7, f"tmp71": tmp71, f"tmp73": tmp73, f"tmp74": tmp74, f"tmp76": tmp76, f"tmp77": tmp77, f"tmp79": tmp79, f"tmp8": tmp8, f"tmp81": tmp81, f"tmp82": tmp82, f"tmp83": tmp83, f"tmp85": tmp85, f"tmp86": tmp86, f"tmp88": tmp88, f"tmp89": tmp89, f"tmp90": tmp90, f"tmp92": tmp92, f"tmp94": tmp94, f"tmp96": tmp96, f"tmp98": tmp98} + +def hbar_lmatvec_ea(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:25:19.936973. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + r1 : Namespace of arrays + R1 amplitudes. + r2 : Namespace of arrays + R2 amplitudes. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + r1new : Namespace of arrays + Updated R1 residuals. + r2new : Namespace of arrays + Updated R2 residuals. + """ + + ints = kwargs["ints"] + r1new = Namespace() + r2new = Namespace() + tmp119 = f.bb.ov.copy() + tmp119 += ints.tmp33 + tmp119 += ints.tmp35 + tmp95 = ints.tmp114.copy() * -1 + tmp95 += ints.tmp114.transpose((0, 2, 1, 3)) + tmp44 = ints.tmp111.copy() * -1 + tmp44 += ints.tmp111.transpose((0, 2, 1, 3)) + tmp62 = f.aa.ov.copy() + tmp62 += ints.tmp29 + tmp62 += ints.tmp36 + tmp120 = einsum(t1.bb, (0, 1), tmp119, (0, 2), (1, 2)) + del tmp119 + tmp101 = einsum(ints.tmp89, (0, 1), t1.bb, (0, 2), (1, 2)) + tmp109 = einsum(v.aabb.ooov, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 4, 3)) + tmp36 = einsum(t2.bbbb, (0, 1, 2, 3), r2.bbb, (2, 3, 1), (0,)) + tmp35 = einsum(t2.abab, (0, 1, 2, 3), r2.aba, (2, 3, 0), (1,)) + tmp96 = einsum(tmp95, (0, 1, 2, 3), t1.bb, (1, 4), (0, 2, 4, 3)) + del tmp95 + tmp106 = einsum(ints.tmp117, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 4, 3)) + tmp48 = einsum(ints.tmp120, (0, 1, 2, 3), t1.bb, (2, 4), (0, 1, 3, 4)) + tmp53 = einsum(t1.aa, (0, 1), ints.tmp82, (0, 2), (2, 1)) + tmp45 = einsum(t1.aa, (0, 1), tmp44, (2, 0, 3, 4), (2, 3, 1, 4)) + del tmp44 + tmp63 = einsum(t1.aa, (0, 1), tmp62, (0, 2), (1, 2)) + del tmp62 + tmp15 = einsum(r1.a, (0,), t1.aa, (1, 0), (1,)) + tmp17 = einsum(r2.bab, (0, 1, 2), t2.abab, (3, 2, 1, 0), (3,)) * -1 + tmp115 = ints.tmp284.copy() + tmp115 += ints.tmp310 + tmp115 += ints.tmp290 * 2 + tmp121 = ints.tmp175.copy() + tmp121 += tmp120.transpose((1, 0)) + del tmp120 + tmp34 = einsum(r1.b, (0,), t1.bb, (1, 0), (1,)) + tmp117 = ints.tmp305.transpose((0, 1, 3, 2)).copy() + tmp117 += ints.tmp288 * 2 + tmp102 = f.bb.vv.copy() * 0.5 + tmp102 += ints.tmp173 * 0.5 + tmp102 += ints.tmp177 * 0.5 + tmp102 += ints.tmp230 * -1 + tmp102 += ints.tmp232 * -0.5 + tmp102 += tmp101.transpose((1, 0)) * 0.5 + del tmp101 + tmp110 = v.aabb.ovov.transpose((0, 2, 1, 3)).copy() + tmp110 += tmp109 * -1 + del tmp109 + tmp104 = tmp35.copy() * -0.5 + tmp104 += tmp36 + tmp97 = ints.tmp285.copy() * 2 + tmp97 += ints.tmp292 + tmp97 += ints.tmp307.transpose((0, 1, 3, 2)) + tmp97 += tmp96 * -1 + del tmp96 + tmp22 = einsum(t1.bb, (0, 1), r2.bbb, (2, 1, 3), (3, 0, 2)) + tmp99 = v.bbbb.ooov.copy() * -1 + tmp99 += v.bbbb.ooov.transpose((0, 2, 1, 3)) + tmp107 = ints.tmp287.copy() + tmp107 += tmp106 + del tmp106 + tmp38 = f.bb.ov.copy() + tmp38 += ints.tmp33 + tmp38 += ints.tmp35 + tmp38 += ints.tmp89 * -1 + tmp19 = f.aa.ov.copy() + tmp19 += ints.tmp29 + tmp19 += ints.tmp36 + tmp19 += ints.tmp82 * -1 + tmp49 = ints.tmp141.copy() * 0.5 + tmp49 += ints.tmp147 + tmp49 += ints.tmp186 * 0.5 + tmp49 += tmp48 * -0.5 + del tmp48 + tmp2 = einsum(t1.aa, (0, 1), r2.aaa, (2, 1, 3), (3, 0, 2)) + tmp51 = v.aaaa.ooov.copy() * -1 + tmp51 += v.aaaa.ooov.transpose((0, 2, 1, 3)) + tmp54 = f.aa.vv.copy() * 0.5 + tmp54 += ints.tmp26 * 0.5 + tmp54 += ints.tmp28 * 0.5 + tmp54 += ints.tmp47 * -1 + tmp54 += ints.tmp49 * -0.5 + tmp54 += tmp53.transpose((1, 0)) * 0.5 + del tmp53 + tmp6 = einsum(r2.bab, (0, 1, 2), t1.bb, (3, 0), (2, 3, 1)) * -1 + tmp46 = ints.tmp139.copy() * 2 + tmp46 += ints.tmp145 + tmp46 += ints.tmp183.transpose((0, 1, 3, 2)) + tmp46 += tmp45 * -1 + del tmp45 + tmp16 = einsum(r2.aaa, (0, 1, 2), t2.aaaa, (3, 2, 0, 1), (3,)) + tmp60 = ints.tmp181.transpose((0, 1, 3, 2)).copy() + tmp60 += ints.tmp142 * 2 + tmp64 = ints.tmp27.copy() + tmp64 += tmp63.transpose((1, 0)) + del tmp63 + tmp66 = tmp15.copy() + tmp66 += tmp17 + tmp124 = t2.bbbb.copy() + tmp124 += einsum(t1.bb, (0, 1), t1.bb, (2, 3), (2, 0, 3, 1)) + tmp116 = einsum(tmp115, (0, 1, 2, 3), r2.aba, (2, 4, 0), (1, 4, 3)) + del tmp115 + tmp113 = einsum(v.bbbb.ovov, (0, 1, 2, 3), r2.bbb, (4, 3, 2), (0, 4, 1)) + tmp122 = einsum(tmp121, (0, 1), r2.bbb, (2, 1, 3), (3, 2, 0)) * -1 + del tmp121 + tmp114 = einsum(tmp34, (0,), v.bbbb.ovov, (1, 2, 0, 3), (1, 2, 3)) + tmp118 = einsum(r2.bbb, (0, 1, 2), tmp117, (2, 3, 1, 4), (3, 0, 4)) * -1 + del tmp117 + tmp103 = einsum(tmp102, (0, 1), r2.bbb, (2, 0, 3), (3, 2, 1)) * -4 + del tmp102 + tmp111 = einsum(tmp110, (0, 1, 2, 3), r2.aba, (2, 4, 0), (1, 4, 3)) + del tmp110 + tmp93 = einsum(r2.bbb, (0, 1, 2), v.bbbb.oovv, (3, 2, 4, 1), (3, 0, 4)) + tmp92 = einsum(r1.b, (0,), v.bbbb.ovvv, (1, 2, 3, 0), (1, 2, 3)) + tmp105 = einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp104, (2,), (0, 3, 1)) * 2 + del tmp104 + tmp98 = einsum(r2.bbb, (0, 1, 2), tmp97, (2, 3, 1, 4), (3, 0, 4)) * -2 + del tmp97 + tmp94 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), tmp22, (4, 0, 3), (4, 1, 2)) * -1 + tmp100 = einsum(tmp99, (0, 1, 2, 3), tmp22, (0, 1, 4), (2, 4, 3)) * 2 + del tmp99 + tmp108 = einsum(tmp107, (0, 1, 2, 3), r2.aba, (2, 4, 0), (1, 4, 3)) + del tmp107 + tmp81 = einsum(t1.bb, (0, 1), tmp38, (0, 2), (1, 2)) + tmp87 = t2.abab.copy() + tmp87 += einsum(t1.aa, (0, 1), t1.bb, (2, 3), (0, 2, 1, 3)) + tmp30 = ints.tmp117.copy() + tmp30 += v.aabb.ooov + tmp79 = einsum(t1.aa, (0, 1), tmp19, (0, 2), (1, 2)) + tmp74 = ints.tmp120.copy() + tmp74 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp83 = ints.tmp114.copy() * -1 + tmp83 += ints.tmp114.transpose((0, 2, 1, 3)) + tmp83 += v.bbbb.ooov + tmp83 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -1 + tmp72 = ints.tmp111.copy() * -1 + tmp72 += ints.tmp111.transpose((0, 2, 1, 3)) + tmp72 += v.aaaa.ooov + tmp72 += v.aaaa.ooov.transpose((0, 2, 1, 3)) * -1 + tmp77 = t2.abab.copy() + tmp77 += einsum(t1.aa, (0, 1), t1.bb, (2, 3), (0, 2, 1, 3)) + tmp50 = einsum(r2.bab, (0, 1, 2), tmp49, (3, 2, 4, 0), (3, 1, 4)) * -2 + del tmp49 + tmp41 = einsum(tmp2, (0, 1, 2), v.aaaa.ovvv, (1, 3, 4, 2), (0, 3, 4)) * -1 + tmp52 = einsum(tmp51, (0, 1, 2, 3), tmp2, (0, 1, 4), (2, 4, 3)) * 2 + del tmp51 + tmp40 = einsum(v.aaaa.oovv, (0, 1, 2, 3), r2.aaa, (4, 3, 1), (0, 4, 2)) + tmp55 = einsum(r2.aaa, (0, 1, 2), tmp54, (1, 3), (2, 0, 3)) * -4 + del tmp54 + tmp42 = einsum(tmp6, (0, 1, 2), v.aabb.ovoo, (3, 4, 1, 0), (3, 2, 4)) + tmp47 = einsum(tmp46, (0, 1, 2, 3), r2.aaa, (4, 2, 0), (1, 4, 3)) * -2 + del tmp46 + tmp43 = einsum(tmp16, (0,), v.aaaa.ovov, (1, 2, 0, 3), (1, 2, 3)) * -1 + tmp39 = einsum(r1.a, (0,), v.aaaa.ovvv, (1, 2, 3, 0), (1, 2, 3)) + tmp69 = t2.aaaa.copy() + tmp69 += einsum(t1.aa, (0, 1), t1.aa, (2, 3), (2, 0, 3, 1)) + tmp59 = einsum(r2.bab, (0, 1, 2), v.aabb.ovov, (3, 4, 2, 0), (3, 1, 4)) * -1 + tmp61 = einsum(tmp60, (0, 1, 2, 3), r2.aaa, (4, 2, 0), (1, 4, 3)) * -1 + del tmp60 + tmp58 = einsum(r2.bab, (0, 1, 2), ints.tmp144, (3, 2, 4, 0), (3, 4, 1)) * -1 + tmp65 = einsum(r2.aaa, (0, 1, 2), tmp64, (3, 1), (2, 0, 3)) * -1 + del tmp64 + tmp67 = einsum(v.aaaa.ovov, (0, 1, 2, 3), tmp66, (2,), (0, 3, 1)) + del tmp66 + tmp57 = einsum(v.aaaa.ovov, (0, 1, 2, 3), r2.aaa, (4, 3, 2), (0, 4, 1)) + tmp26 = einsum(r2.aba, (0, 1, 2), t1.aa, (3, 0), (2, 3, 1)) + tmp125 = einsum(r2.bbb, (0, 1, 2), tmp124, (3, 4, 0, 1), (2, 4, 3)) * -1 + del tmp124 + tmp123 = tmp113.copy() * 2 + del tmp113 + tmp123 += tmp114 + del tmp114 + tmp123 += tmp116.transpose((0, 2, 1)) + del tmp116 + tmp123 += tmp118.transpose((0, 2, 1)) * -2 + del tmp118 + tmp123 += tmp122.transpose((0, 2, 1)) * -2 + del tmp122 + tmp112 = tmp92.copy() + del tmp92 + tmp112 += tmp93 * 2 + del tmp93 + tmp112 += tmp94 * 2 + del tmp94 + tmp112 += tmp98.transpose((0, 2, 1)) * -1 + del tmp98 + tmp112 += tmp100 * -1 + del tmp100 + tmp112 += tmp103.transpose((0, 2, 1)) * -1 + del tmp103 + tmp112 += tmp105.transpose((0, 2, 1)) * -1 + del tmp105 + tmp112 += tmp108.transpose((0, 2, 1)) + del tmp108 + tmp112 += tmp111 + del tmp111 + tmp91 = f.bb.oo.copy() + tmp91 += ints.tmp130 * 2 + tmp91 += ints.tmp133 + tmp91 += ints.tmp158 + tmp91 += ints.tmp163 + tmp91 += ints.tmp195 + tmp91 += ints.tmp200 + tmp91 += ints.tmp22.transpose((1, 0)) + tmp91 += ints.tmp156 * -1 + tmp91 += ints.tmp193 * -1 + tmp4 = einsum(r2.bab, (0, 1, 2), t1.aa, (3, 1), (3, 2, 0)) * -1 + tmp89 = ints.tmp175.transpose((1, 0)).copy() + tmp89 += ints.tmp230 * 2 + tmp89 += ints.tmp232 + tmp89 += f.bb.vv * -1 + tmp89 += ints.tmp173 * -1 + tmp89 += ints.tmp177 * -1 + tmp89 += tmp81 + tmp88 = einsum(r2.bab, (0, 1, 2), tmp87, (3, 4, 1, 0), (3, 2, 4)) * -1 + del tmp87 + tmp85 = ints.tmp284.copy() + tmp85 += ints.tmp290 * 2 + tmp85 += ints.tmp310 + tmp85 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp85 += ints.tmp287 * -1 + tmp85 += einsum(tmp30, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 4, 3)) * -1 + tmp18 = tmp15.copy() + del tmp15 + tmp18 += tmp16 * 2 + del tmp16 + tmp18 += tmp17 + del tmp17 + tmp90 = ints.tmp27.transpose((1, 0)).copy() + tmp90 += ints.tmp47 * 2 + tmp90 += ints.tmp49 + tmp90 += f.aa.vv * -1 + tmp90 += ints.tmp26.transpose((1, 0)) * -1 + tmp90 += ints.tmp28.transpose((1, 0)) * -1 + tmp90 += tmp79 + tmp86 = ints.tmp149.copy() + tmp86 += ints.tmp185.transpose((0, 1, 3, 2)) * -1 + tmp86 += v.aabb.vvoo.transpose((2, 3, 0, 1)) * -1 + tmp86 += einsum(t1.aa, (0, 1), tmp74, (0, 2, 3, 4), (2, 3, 1, 4)) + tmp84 = ints.tmp285.copy() * 2 + tmp84 += ints.tmp292 + tmp84 += ints.tmp307.transpose((0, 1, 3, 2)) + tmp84 += v.bbbb.ovov.transpose((0, 2, 1, 3)) + tmp84 += ints.tmp288 * -2 + tmp84 += ints.tmp305.transpose((0, 1, 3, 2)) * -1 + tmp84 += v.bbbb.oovv * -1 + tmp84 += einsum(tmp83, (0, 1, 2, 3), t1.bb, (1, 4), (0, 2, 4, 3)) * -1 + del tmp83 + tmp80 = ints.tmp27.transpose((1, 0)).copy() + tmp80 += ints.tmp47 * 2 + tmp80 += ints.tmp49 + tmp80 += f.aa.vv * -1 + tmp80 += ints.tmp26 * -1 + tmp80 += ints.tmp28 * -1 + tmp80 += tmp79 + del tmp79 + tmp75 = ints.tmp141.copy() + tmp75 += ints.tmp147 * 2 + tmp75 += ints.tmp186 + tmp75 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp75 += ints.tmp144 * -1 + tmp75 += einsum(t1.bb, (0, 1), tmp74, (2, 3, 0, 4), (2, 3, 4, 1)) * -1 + del tmp74 + tmp71 = f.aa.oo.copy() + tmp71 += ints.tmp127 * 2 + tmp71 += ints.tmp136 + tmp71 += ints.tmp153 + tmp71 += ints.tmp160 + tmp71 += ints.tmp190 + tmp71 += ints.tmp197 + tmp71 += ints.tmp19.transpose((1, 0)) + tmp71 += ints.tmp150 * -1 + tmp71 += ints.tmp187 * -1 + tmp73 = ints.tmp139.copy() * 2 + tmp73 += ints.tmp145 + tmp73 += ints.tmp183.transpose((0, 1, 3, 2)) + tmp73 += v.aaaa.ovov.transpose((0, 2, 1, 3)) + tmp73 += ints.tmp142 * -2 + tmp73 += ints.tmp181.transpose((0, 1, 3, 2)) * -1 + tmp73 += v.aaaa.oovv * -1 + tmp73 += einsum(t1.aa, (0, 1), tmp72, (2, 0, 3, 4), (2, 3, 1, 4)) * -1 + del tmp72 + tmp24 = einsum(t1.bb, (0, 1), r2.aba, (2, 1, 3), (3, 0, 2)) + tmp76 = ints.tmp294.copy() + tmp76 += ints.tmp309.transpose((0, 1, 3, 2)) * -1 + tmp76 += v.aabb.oovv * -1 + tmp76 += einsum(t1.bb, (0, 1), tmp30, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp82 = ints.tmp175.transpose((1, 0)).copy() + tmp82 += ints.tmp230 * 2 + tmp82 += ints.tmp232 + tmp82 += f.bb.vv * -1 + tmp82 += ints.tmp173.transpose((1, 0)) * -1 + tmp82 += ints.tmp177.transpose((1, 0)) * -1 + tmp82 += tmp81 + del tmp81 + tmp78 = einsum(tmp77, (0, 1, 2, 3), r2.aba, (2, 3, 4), (4, 0, 1)) + del tmp77 + tmp37 = tmp34.copy() + del tmp34 + tmp37 += tmp35 * -1 + del tmp35 + tmp37 += tmp36 * 2 + del tmp36 + tmp56 = tmp39.copy() + del tmp39 + tmp56 += tmp40 * 2 + del tmp40 + tmp56 += tmp41 * 2 + del tmp41 + tmp56 += tmp42 + del tmp42 + tmp56 += tmp43 * 2 + del tmp43 + tmp56 += tmp47.transpose((0, 2, 1)) * -1 + del tmp47 + tmp56 += tmp50.transpose((0, 2, 1)) + del tmp50 + tmp56 += tmp52 * -1 + del tmp52 + tmp56 += tmp55.transpose((0, 2, 1)) * -1 + del tmp55 + tmp70 = einsum(tmp69, (0, 1, 2, 3), r2.aaa, (2, 3, 4), (4, 1, 0)) * -1 + del tmp69 + tmp68 = tmp57.copy() * 2 + del tmp57 + tmp68 += tmp58 + del tmp58 + tmp68 += tmp59 + del tmp59 + tmp68 += tmp61.transpose((0, 2, 1)) * -2 + del tmp61 + tmp68 += tmp65.transpose((0, 2, 1)) * -2 + del tmp65 + tmp68 += tmp67.transpose((0, 2, 1)) + del tmp67 + tmp31 = einsum(t1.bb, (0, 1), tmp22, (2, 3, 1), (2, 3, 0)) * -1 + tmp32 = ints.tmp114.copy() + tmp32 += v.bbbb.ooov * -1 + tmp21 = ints.tmp238.transpose((0, 3, 1, 2)).copy() * 0.5 + tmp21 += ints.tmp247.transpose((0, 2, 1, 3)) + tmp21 += ints.tmp254.transpose((0, 2, 1, 3)) * 0.5 + tmp21 += v.bbbb.ovvv.transpose((0, 2, 1, 3)) * 0.5 + tmp21 += ints.tmp226 * -0.5 + tmp21 += ints.tmp250.transpose((0, 2, 1, 3)) * -1 + tmp21 += ints.tmp276.transpose((0, 3, 1, 2)) * -0.5 + tmp27 = ints.tmp309.transpose((0, 1, 3, 2)).copy() + tmp27 += v.aabb.oovv + tmp27 += ints.tmp294 * -1 + tmp29 = einsum(t1.bb, (0, 1), tmp26, (2, 3, 1), (2, 3, 0)) + tmp33 = ints.tmp175.transpose((1, 0)).copy() + tmp33 += ints.tmp230 * 2 + tmp33 += ints.tmp232 + tmp33 += f.bb.vv * -1 + tmp33 += ints.tmp173.transpose((1, 0)) * -1 + tmp33 += ints.tmp177.transpose((1, 0)) * -1 + tmp28 = ints.tmp112.copy() * 2 + tmp28 += ints.tmp118 + tmp28 += ints.tmp128 * 2 + tmp28 += ints.tmp137 + tmp28 += ints.tmp154 + tmp28 += ints.tmp161 + tmp28 += ints.tmp171 + tmp28 += ints.tmp191 + tmp28 += ints.tmp198 + tmp28 += ints.tmp20 + tmp28 += ints.tmp2 + tmp28 += ints.tmp31 + tmp28 += ints.tmp51 * 2 + tmp28 += ints.tmp57 + tmp28 += ints.tmp63 * 2 + tmp28 += ints.tmp83 * 2 + tmp28 += ints.tmp90 + tmp28 += f.aa.ov * -1 + tmp28 += ints.tmp101 * -1 + tmp28 += ints.tmp11 * -1 + tmp28 += ints.tmp151 * -1 + tmp28 += ints.tmp169 * -1 + tmp28 += ints.tmp179 * -1 + tmp28 += ints.tmp188 * -1 + tmp28 += ints.tmp29 * -1 + tmp28 += ints.tmp36 * -1 + tmp28 += ints.tmp5 * -1 + tmp28 += ints.tmp69 * -1 + tmp28 += ints.tmp86 * -2 + tmp28 += ints.tmp8 * -2 + tmp28 += ints.tmp94 * -1 + tmp28 += ints.tmp98 * -2 + tmp23 = ints.tmp285.copy() * 2 + tmp23 += ints.tmp292 + tmp23 += ints.tmp307.transpose((0, 1, 3, 2)) + tmp23 += v.bbbb.ovov.transpose((0, 2, 1, 3)) + tmp23 += ints.tmp288 * -2 + tmp23 += ints.tmp305.transpose((0, 1, 3, 2)) * -1 + tmp23 += v.bbbb.oovv * -1 + tmp20 = ints.tmp228.copy() + tmp20 += ints.tmp240.transpose((0, 1, 3, 2)) + tmp20 += ints.tmp246 + tmp20 += ints.tmp252 * 2 + tmp20 += ints.tmp278.transpose((0, 1, 3, 2)) + tmp20 += v.aabb.ovvv + tmp20 += ints.tmp249 * -1 + tmp20 += ints.tmp256.transpose((0, 1, 3, 2)) * -1 + tmp25 = ints.tmp284.copy() + tmp25 += ints.tmp290 * 2 + tmp25 += ints.tmp310 + tmp25 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp25 += ints.tmp287 * -1 + tmp9 = ints.tmp115.copy() * 2 + tmp9 += ints.tmp121 + tmp9 += ints.tmp131 * 2 + tmp9 += ints.tmp134 + tmp9 += ints.tmp159 + tmp9 += ints.tmp164 + tmp9 += ints.tmp176 + tmp9 += ints.tmp196 + tmp9 += ints.tmp201 + tmp9 += ints.tmp23 + tmp9 += ints.tmp34 + tmp9 += ints.tmp4 + tmp9 += ints.tmp53 * 2 + tmp9 += ints.tmp55 + tmp9 += ints.tmp65 * 2 + tmp9 += ints.tmp85 + tmp9 += ints.tmp92 * 2 + tmp9 += f.bb.ov * -1 + tmp9 += ints.tmp100 * -1 + tmp9 += ints.tmp103 * -2 + tmp9 += ints.tmp10 * -1 + tmp9 += ints.tmp13 * -2 + tmp9 += ints.tmp157 * -1 + tmp9 += ints.tmp174 * -1 + tmp9 += ints.tmp178 * -1 + tmp9 += ints.tmp194 * -1 + tmp9 += ints.tmp33 * -1 + tmp9 += ints.tmp35 * -1 + tmp9 += ints.tmp67 * -1 + tmp9 += ints.tmp7 * -1 + tmp9 += ints.tmp88 * -1 + tmp9 += ints.tmp96 * -2 + tmp10 = einsum(tmp6, (0, 1, 2), t1.aa, (3, 2), (3, 0, 1)) + tmp5 = ints.tmp141.copy() + tmp5 += ints.tmp147 * 2 + tmp5 += ints.tmp186 + tmp5 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp5 += ints.tmp144 * -1 + tmp0 = ints.tmp125.copy() + tmp0 += ints.tmp45.transpose((0, 2, 1, 3)) + tmp0 += ints.tmp61 + tmp0 += ints.tmp73.transpose((0, 2, 1, 3)) + tmp0 += ints.tmp79.transpose((0, 2, 1, 3)) * 2 + tmp0 += v.aabb.vvov.transpose((2, 0, 1, 3)) + tmp0 += ints.tmp76.transpose((0, 2, 1, 3)) * -1 + tmp0 += ints.tmp81 * -1 + tmp11 = ints.tmp120.copy() + tmp11 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp7 = ints.tmp185.transpose((0, 1, 3, 2)).copy() + tmp7 += v.aabb.vvoo.transpose((2, 3, 0, 1)) + tmp7 += ints.tmp149 * -1 + tmp8 = ints.tmp112.copy() + tmp8 += ints.tmp118 * 0.5 + tmp8 += ints.tmp128 + tmp8 += ints.tmp137 * 0.5 + tmp8 += ints.tmp154 * 0.5 + tmp8 += ints.tmp161 * 0.5 + tmp8 += ints.tmp171 * 0.5 + tmp8 += ints.tmp191 * 0.5 + tmp8 += ints.tmp198 * 0.5 + tmp8 += ints.tmp20 * 0.5 + tmp8 += ints.tmp2 * 0.5 + tmp8 += ints.tmp31 * 0.5 + tmp8 += ints.tmp51 + tmp8 += ints.tmp57 * 0.5 + tmp8 += ints.tmp63 + tmp8 += ints.tmp83 + tmp8 += ints.tmp90 * 0.5 + tmp8 += f.aa.ov * -0.5 + tmp8 += ints.tmp101 * -0.5 + tmp8 += ints.tmp11 * -0.5 + tmp8 += ints.tmp151 * -0.5 + tmp8 += ints.tmp169 * -0.5 + tmp8 += ints.tmp179 * -0.5 + tmp8 += ints.tmp188 * -0.5 + tmp8 += ints.tmp29 * -0.5 + tmp8 += ints.tmp36 * -0.5 + tmp8 += ints.tmp5 * -0.5 + tmp8 += ints.tmp69 * -0.5 + tmp8 += ints.tmp86 * -1 + tmp8 += ints.tmp8 * -1 + tmp8 += ints.tmp94 * -0.5 + tmp8 += ints.tmp98 * -1 + tmp14 = ints.tmp27.transpose((1, 0)).copy() + tmp14 += ints.tmp47 * 2 + tmp14 += ints.tmp49 + tmp14 += f.aa.vv * -1 + tmp14 += ints.tmp26.transpose((1, 0)) * -1 + tmp14 += ints.tmp28.transpose((1, 0)) * -1 + tmp3 = ints.tmp139.copy() * 2 + tmp3 += ints.tmp145 + tmp3 += ints.tmp183.transpose((0, 1, 3, 2)) + tmp3 += v.aaaa.ovov.transpose((0, 2, 1, 3)) + tmp3 += ints.tmp142 * -2 + tmp3 += ints.tmp181.transpose((0, 1, 3, 2)) * -1 + tmp3 += v.aaaa.oovv * -1 + tmp13 = ints.tmp111.copy() + tmp13 += v.aaaa.ooov * -1 + tmp1 = ints.tmp59.copy() * 0.5 + tmp1 += ints.tmp71.transpose((0, 1, 3, 2)) + tmp1 += ints.tmp77.transpose((0, 1, 3, 2)) * 0.5 + tmp1 += v.aaaa.ovvv * 0.5 + tmp1 += ints.tmp123 * -0.5 + tmp1 += ints.tmp43.transpose((0, 2, 3, 1)) * -0.5 + tmp1 += ints.tmp74.transpose((0, 1, 3, 2)) * -1 + tmp12 = einsum(t1.aa, (0, 1), tmp2, (2, 3, 1), (2, 3, 0)) * -1 + r2new.bbb = einsum(v.bbbb.vvvv, (0, 1, 2, 3), r2.bbb, (1, 3, 4), (0, 2, 4)) * 2 + r2new.bbb += tmp112.transpose((1, 2, 0)) * -1 + r2new.bbb += tmp112.transpose((2, 1, 0)) + del tmp112 + r2new.bbb += tmp123.transpose((1, 2, 0)) + r2new.bbb += tmp123.transpose((2, 1, 0)) * -1 + del tmp123 + r2new.bbb += einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp125, (4, 0, 2), (3, 1, 4)) * -2 + del tmp125 + r2new.bbb += einsum(tmp91, (0, 1), r2.bbb, (2, 3, 0), (2, 3, 1)) * -2 + r2new.bbb += einsum(r1.b, (0,), tmp38, (1, 2), (0, 2, 1)) + r2new.bbb += einsum(tmp38, (0, 1), r1.b, (2,), (1, 2, 0)) * -1 + r2new.bab = einsum(tmp4, (0, 1, 2), v.aabb.ovvv, (0, 3, 4, 2), (4, 3, 1)) + r2new.bab += einsum(v.aabb.vvov, (0, 1, 2, 3), tmp6, (4, 2, 1), (3, 0, 4)) + r2new.bab += einsum(v.aabb.vvvv, (0, 1, 2, 3), r2.bab, (3, 1, 4), (2, 0, 4)) + r2new.bab += einsum(v.aabb.vvov, (0, 1, 2, 3), r1.a, (1,), (3, 0, 2)) * -1 + r2new.bab += einsum(r2.bab, (0, 1, 2), tmp84, (2, 3, 0, 4), (4, 1, 3)) + del tmp84 + r2new.bab += einsum(r2.aaa, (0, 1, 2), tmp85, (2, 3, 1, 4), (4, 0, 3)) * -2 + del tmp85 + r2new.bab += einsum(tmp86, (0, 1, 2, 3), r2.bab, (4, 2, 0), (4, 3, 1)) + del tmp86 + r2new.bab += einsum(tmp88, (0, 1, 2), v.aabb.ovov, (0, 3, 2, 4), (4, 3, 1)) * -1 + del tmp88 + r2new.bab += einsum(tmp89, (0, 1), r2.bab, (0, 2, 3), (1, 2, 3)) * -1 + del tmp89 + r2new.bab += einsum(r2.bab, (0, 1, 2), tmp90, (1, 3), (0, 3, 2)) * -1 + del tmp90 + r2new.bab += einsum(tmp91, (0, 1), r2.bab, (2, 3, 0), (2, 3, 1)) * -1 + del tmp91 + r2new.bab += einsum(tmp18, (0,), v.aabb.ovov, (0, 1, 2, 3), (3, 1, 2)) + r2new.bab += einsum(r1.a, (0,), tmp38, (1, 2), (2, 0, 1)) * -1 + r2new.aba = einsum(v.aabb.vvov, (0, 1, 2, 3), tmp24, (4, 2, 1), (0, 3, 4)) * -1 + r2new.aba += einsum(r2.aba, (0, 1, 2), v.aabb.vvvv, (3, 0, 4, 1), (3, 4, 2)) + r2new.aba += einsum(v.aabb.ovvv, (0, 1, 2, 3), r1.b, (3,), (1, 2, 0)) * -1 + r2new.aba += einsum(tmp26, (0, 1, 2), v.aabb.ovvv, (1, 3, 4, 2), (3, 4, 0)) * -1 + r2new.aba += einsum(tmp73, (0, 1, 2, 3), r2.aba, (2, 4, 0), (3, 4, 1)) + del tmp73 + r2new.aba += einsum(tmp75, (0, 1, 2, 3), r2.bbb, (4, 3, 1), (2, 4, 0)) * -2 + del tmp75 + r2new.aba += einsum(r2.aba, (0, 1, 2), tmp76, (2, 3, 1, 4), (0, 4, 3)) + del tmp76 + r2new.aba += einsum(v.aabb.ovov, (0, 1, 2, 3), tmp78, (4, 0, 2), (1, 3, 4)) + del tmp78 + r2new.aba += einsum(r2.aba, (0, 1, 2), tmp80, (0, 3), (3, 1, 2)) * -1 + del tmp80 + r2new.aba += einsum(tmp82, (0, 1), r2.aba, (2, 0, 3), (2, 1, 3)) * -1 + del tmp82 + r2new.aba += einsum(tmp71, (0, 1), r2.aba, (2, 3, 0), (2, 3, 1)) * -1 + r2new.aba += einsum(v.aabb.ovov, (0, 1, 2, 3), tmp37, (2,), (1, 3, 0)) + r2new.aba += einsum(r1.b, (0,), tmp19, (1, 2), (2, 0, 1)) * -1 + r2new.aaa = einsum(r2.aaa, (0, 1, 2), v.aaaa.vvvv, (3, 1, 4, 0), (3, 4, 2)) * -2 + r2new.aaa += tmp56.transpose((1, 2, 0)) * -1 + r2new.aaa += tmp56.transpose((2, 1, 0)) + del tmp56 + r2new.aaa += tmp68.transpose((1, 2, 0)) + r2new.aaa += tmp68.transpose((2, 1, 0)) * -1 + del tmp68 + r2new.aaa += einsum(v.aaaa.ovov, (0, 1, 2, 3), tmp70, (4, 0, 2), (3, 1, 4)) * -2 + del tmp70 + r2new.aaa += einsum(r2.aaa, (0, 1, 2), tmp71, (2, 3), (0, 1, 3)) * -2 + del tmp71 + r2new.aaa += einsum(r1.a, (0,), tmp19, (1, 2), (0, 2, 1)) + r2new.aaa += einsum(r1.a, (0,), tmp19, (1, 2), (2, 0, 1)) * -1 + r1new.b = einsum(r2.aba, (0, 1, 2), tmp20, (2, 0, 3, 1), (3,)) * -1 + del tmp20 + r1new.b += einsum(tmp21, (0, 1, 2, 3), r2.bbb, (2, 3, 0), (1,)) * -4 + del tmp21 + r1new.b += einsum(tmp22, (0, 1, 2), tmp23, (0, 1, 2, 3), (3,)) * 2 + del tmp22, tmp23 + r1new.b += einsum(tmp24, (0, 1, 2), tmp25, (0, 1, 2, 3), (3,)) + del tmp24, tmp25 + r1new.b += einsum(tmp27, (0, 1, 2, 3), tmp26, (0, 1, 2), (3,)) + del tmp26, tmp27 + r1new.b += einsum(r2.bbb, (0, 1, 2), tmp9, (2, 1), (0,)) * -2 + r1new.b += einsum(tmp28, (0, 1), r2.aba, (1, 2, 0), (2,)) + del tmp28 + r1new.b += einsum(tmp30, (0, 1, 2, 3), tmp29, (0, 1, 2), (3,)) * -1 + del tmp30, tmp29 + r1new.b += einsum(tmp31, (0, 1, 2), tmp32, (0, 2, 1, 3), (3,)) * -2 + del tmp31, tmp32 + r1new.b += einsum(r1.b, (0,), tmp33, (0, 1), (1,)) * -1 + del tmp33 + r1new.b += einsum(tmp38, (0, 1), tmp37, (0,), (1,)) * -1 + del tmp38, tmp37 + r1new.a = einsum(r2.bab, (0, 1, 2), tmp0, (2, 1, 3, 0), (3,)) * -1 + del tmp0 + r1new.a += einsum(tmp1, (0, 1, 2, 3), r2.aaa, (2, 1, 0), (3,)) * 4 + del tmp1 + r1new.a += einsum(tmp3, (0, 1, 2, 3), tmp2, (0, 1, 2), (3,)) * 2 + del tmp2, tmp3 + r1new.a += einsum(tmp5, (0, 1, 2, 3), tmp4, (0, 1, 3), (2,)) * -1 + del tmp4, tmp5 + r1new.a += einsum(tmp7, (0, 1, 2, 3), tmp6, (0, 1, 2), (3,)) * -1 + del tmp6, tmp7 + r1new.a += einsum(tmp8, (0, 1), r2.aaa, (2, 1, 0), (2,)) * -4 + del tmp8 + r1new.a += einsum(r2.bab, (0, 1, 2), tmp9, (2, 0), (1,)) + del tmp9 + r1new.a += einsum(tmp11, (0, 1, 2, 3), tmp10, (0, 1, 2), (3,)) + del tmp11, tmp10 + r1new.a += einsum(tmp12, (0, 1, 2), tmp13, (0, 2, 1, 3), (3,)) * -2 + del tmp12, tmp13 + r1new.a += einsum(r1.a, (0,), tmp14, (0, 1), (1,)) * -1 + del tmp14 + r1new.a += einsum(tmp18, (0,), tmp19, (0, 1), (1,)) * -1 + del tmp19, tmp18 + + return {f"r1new": r1new, f"r2new": r2new} + +def hbar_lmatvec_ee_intermediates(f=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:30:26.981260. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + tmp1 : array + tmp10 : array + tmp100 : array + tmp102 : array + tmp11 : array + tmp114 : array + tmp115 : array + tmp117 : array + tmp118 : array + tmp120 : array + tmp121 : array + tmp122 : array + tmp124 : array + tmp126 : array + tmp128 : array + tmp13 : array + tmp130 : array + tmp132 : array + tmp133 : array + tmp135 : array + tmp137 : array + tmp139 : array + tmp141 : array + tmp143 : array + tmp145 : array + tmp147 : array + tmp149 : array + tmp15 : array + tmp151 : array + tmp152 : array + tmp154 : array + tmp156 : array + tmp157 : array + tmp159 : array + tmp161 : array + tmp162 : array + tmp164 : array + tmp165 : array + tmp167 : array + tmp169 : array + tmp17 : array + tmp176 : array + tmp178 : array + tmp179 : array + tmp181 : array + tmp182 : array + tmp184 : array + tmp186 : array + tmp187 : array + tmp189 : array + tmp19 : array + tmp190 : array + tmp2 : array + tmp206 : array + tmp207 : array + tmp208 : array + tmp209 : array + tmp21 : array + tmp211 : array + tmp213 : array + tmp214 : array + tmp215 : array + tmp216 : array + tmp217 : array + tmp219 : array + tmp22 : array + tmp220 : array + tmp221 : array + tmp222 : array + tmp224 : array + tmp226 : array + tmp227 : array + tmp228 : array + tmp229 : array + tmp230 : array + tmp231 : array + tmp233 : array + tmp234 : array + tmp236 : array + tmp237 : array + tmp238 : array + tmp239 : array + tmp240 : array + tmp241 : array + tmp242 : array + tmp243 : array + tmp245 : array + tmp247 : array + tmp248 : array + tmp25 : array + tmp250 : array + tmp252 : array + tmp254 : array + tmp255 : array + tmp256 : array + tmp257 : array + tmp258 : array + tmp26 : array + tmp260 : array + tmp261 : array + tmp262 : array + tmp263 : array + tmp265 : array + tmp266 : array + tmp27 : array + tmp274 : array + tmp276 : array + tmp278 : array + tmp280 : array + tmp282 : array + tmp284 : array + tmp286 : array + tmp288 : array + tmp289 : array + tmp291 : array + tmp292 : array + tmp294 : array + tmp296 : array + tmp30 : array + tmp303 : array + tmp305 : array + tmp307 : array + tmp309 : array + tmp31 : array + tmp310 : array + tmp312 : array + tmp313 : array + tmp315 : array + tmp317 : array + tmp32 : array + tmp324 : array + tmp33 : array + tmp333 : array + tmp335 : array + tmp340 : array + tmp341 : array + tmp342 : array + tmp343 : array + tmp345 : array + tmp35 : array + tmp351 : array + tmp353 : array + tmp363 : array + tmp364 : array + tmp366 : array + tmp367 : array + tmp369 : array + tmp37 : array + tmp370 : array + tmp372 : array + tmp384 : array + tmp386 : array + tmp39 : array + tmp4 : array + tmp403 : array + tmp405 : array + tmp407 : array + tmp409 : array + tmp41 : array + tmp411 : array + tmp413 : array + tmp419 : array + tmp42 : array + tmp420 : array + tmp422 : array + tmp423 : array + tmp425 : array + tmp427 : array + tmp429 : array + tmp43 : array + tmp44 : array + tmp440 : array + tmp441 : array + tmp443 : array + tmp454 : array + tmp455 : array + tmp457 : array + tmp459 : array + tmp46 : array + tmp460 : array + tmp464 : array + tmp466 : array + tmp471 : array + tmp472 : array + tmp474 : array + tmp48 : array + tmp482 : array + tmp484 : array + tmp486 : array + tmp488 : array + tmp490 : array + tmp492 : array + tmp494 : array + tmp495 : array + tmp497 : array + tmp498 : array + tmp5 : array + tmp50 : array + tmp500 : array + tmp502 : array + tmp504 : array + tmp51 : array + tmp511 : array + tmp513 : array + tmp515 : array + tmp516 : array + tmp518 : array + tmp519 : array + tmp52 : array + tmp521 : array + tmp523 : array + tmp525 : array + tmp54 : array + tmp63 : array + tmp65 : array + tmp67 : array + tmp69 : array + tmp7 : array + tmp71 : array + tmp73 : array + tmp74 : array + tmp76 : array + tmp77 : array + tmp78 : array + tmp8 : array + tmp80 : array + tmp92 : array + tmp94 : array + tmp96 : array + tmp98 : array + """ + + tmp50 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 0, 2, 3)) + tmp151 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 4, 1), (0, 2, 4, 3)) + tmp46 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t1.aa, (4, 3), (4, 0, 2, 1)) + tmp43 = einsum(t1.aa, (0, 1), v.aabb.ovov, (0, 1, 2, 3), (2, 3)) + tmp44 = einsum(t1.bb, (0, 1), v.aabb.ovov, (2, 3, 0, 1), (2, 3)) + tmp41 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 3, 0, 1), (2, 3)) + tmp121 = einsum(t1.bb, (0, 1), v.bbbb.ovov, (2, 1, 0, 3), (2, 3)) + tmp37 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 3, 0, 1), (2, 3)) + tmp114 = einsum(t1.aa, (0, 1), v.aaaa.ovov, (2, 1, 0, 3), (2, 3)) + tmp265 = einsum(tmp50, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp471 = einsum(t1.bb, (0, 1), tmp151, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp324 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (4, 3), (4, 2, 0, 1)) + tmp341 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp226 = einsum(t1.aa, (0, 1), v.aabb.ovoo, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp228 = einsum(v.aabb.ooov, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp454 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp189 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp440 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovov, (4, 3, 5, 2), (0, 1, 4, 5)) * -1 + tmp156 = einsum(v.aabb.ovov, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 2, 1)) + tmp262 = einsum(t1.aa, (0, 1), tmp46, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp260 = einsum(t1.bb, (0, 1), tmp43, (2, 1), (0, 2)) + tmp208 = einsum(t1.aa, (0, 1), tmp44, (2, 1), (0, 2)) + tmp256 = einsum(t1.bb, (0, 1), tmp41, (2, 1), (0, 2)) + tmp254 = einsum(tmp121, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp207 = einsum(t1.aa, (0, 1), tmp37, (2, 1), (0, 2)) + tmp206 = einsum(t1.aa, (0, 1), tmp114, (2, 1), (0, 2)) + tmp247 = einsum(t1.aa, (0, 1), v.aabb.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp31 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp242 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp240 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.aa, (0, 1), (2, 3)) + tmp238 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 3), (1, 2)) + tmp236 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (0, 1), (2, 3)) + tmp233 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 2, 3, 1), (2, 3)) + tmp230 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (0, 1, 2, 3), (2, 3)) + tmp221 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp219 = einsum(t1.aa, (0, 1), v.aabb.ovoo, (0, 1, 2, 3), (2, 3)) + tmp27 = einsum(t1.bb, (0, 1), v.aabb.ooov, (2, 3, 0, 1), (2, 3)) + tmp215 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (2, 3), (0, 1)) + tmp213 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t1.bb, (1, 3), (0, 2)) + tmp26 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 3, 0, 1), (2, 3)) + tmp25 = einsum(t1.aa, (0, 1), v.aaaa.ooov, (2, 0, 3, 1), (2, 3)) + tmp186 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (4, 3, 5, 2), (0, 1, 4, 5)) * -1 + tmp54 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 3), (4, 0)) + tmp181 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp178 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 1, 3), (4, 0)) + tmp52 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (4, 3, 1, 2), (0, 4)) * -1 + tmp21 = einsum(t1.bb, (0, 1), f.bb.ov, (2, 1), (2, 0)) + tmp1 = einsum(f.aa.ov, (0, 1), t1.aa, (2, 1), (0, 2)) + tmp525 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 1, 5), (4, 0, 5, 3)) + tmp523 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 5, 3)) + tmp521 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 2, 5, 3)) + tmp519 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovov, (4, 3, 1, 5), (0, 4, 2, 5)) + tmp518 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp516 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp515 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovov, (4, 5, 1, 3), (0, 4, 2, 5)) + tmp513 = einsum(tmp50, (0, 1, 2, 3), t2.abab, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp511 = einsum(tmp151, (0, 1, 2, 3), t2.bbbb, (2, 1, 4, 5), (0, 4, 5, 3)) * -1 + tmp504 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 1, 5), (0, 4, 3, 5)) + tmp502 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 5, 2, 3)) + tmp500 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 5, 2, 3)) + tmp498 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 5, 3), (4, 5, 1, 2)) + tmp497 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp495 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 5, 1), (4, 5, 2, 3)) + tmp494 = einsum(t2.abab, (0, 1, 2, 3), v.bbbb.ovvv, (1, 3, 4, 5), (0, 2, 4, 5)) + tmp492 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.abab, (1, 2, 4, 5), (0, 4, 5, 3)) + tmp490 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (2, 1, 4, 5), (0, 4, 5, 3)) * -1 + tmp488 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (0, 2, 1, 4), (4, 3)) + tmp486 = einsum(v.bbbb.ovov, (0, 1, 2, 3), t2.bbbb, (0, 2, 4, 3), (4, 1)) + tmp484 = einsum(t1.aa, (0, 1), v.aabb.vvvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp482 = einsum(v.bbbb.vvvv, (0, 1, 2, 3), t1.bb, (4, 3), (4, 0, 1, 2)) + tmp474 = einsum(tmp265, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp472 = einsum(t1.bb, (0, 1), tmp471, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp466 = einsum(t1.aa, (0, 1), tmp324, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp464 = einsum(t1.bb, (0, 1), tmp341, (2, 3, 1, 4), (0, 2, 3, 4)) + tmp460 = einsum(tmp226, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp459 = einsum(tmp228, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp457 = einsum(t1.bb, (0, 1), tmp454, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp455 = einsum(t1.bb, (0, 1), tmp454, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp443 = einsum(tmp189, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp441 = einsum(t1.bb, (0, 1), tmp440, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp429 = einsum(tmp50, (0, 1, 2, 3), t2.abab, (1, 4, 5, 3), (0, 4, 2, 5)) + tmp427 = einsum(t2.abab, (0, 1, 2, 3), tmp156, (0, 4, 5, 2), (4, 1, 5, 3)) + tmp425 = einsum(tmp156, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 3), (4, 1, 2, 5)) + tmp423 = einsum(tmp151, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp422 = einsum(tmp151, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp420 = einsum(t2.bbbb, (0, 1, 2, 3), tmp151, (4, 1, 5, 3), (4, 0, 5, 2)) + tmp419 = einsum(tmp151, (0, 1, 2, 3), t2.abab, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp413 = einsum(tmp43, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp411 = einsum(t2.abab, (0, 1, 2, 3), tmp43, (4, 3), (0, 1, 4, 2)) + tmp409 = einsum(tmp41, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp407 = einsum(t2.abab, (0, 1, 2, 3), tmp41, (4, 3), (0, 1, 4, 2)) + tmp405 = einsum(tmp121, (0, 1), t2.bbbb, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp403 = einsum(tmp121, (0, 1), t2.abab, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp386 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 5, 3), (0, 1, 5, 4)) + tmp384 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ovvv, (4, 3, 5, 2), (0, 1, 4, 5)) * -1 + tmp372 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 3, 5)) + tmp370 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 2, 3, 5)) + tmp369 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ooov, (4, 0, 5, 3), (4, 1, 5, 2)) + tmp367 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp366 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp364 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp363 = einsum(v.bbbb.ooov, (0, 1, 2, 3), t2.abab, (4, 1, 5, 3), (4, 0, 2, 5)) + tmp353 = einsum(t1.aa, (0, 1), v.aabb.vvoo, (2, 1, 3, 4), (0, 3, 4, 2)) + tmp351 = einsum(t1.bb, (0, 1), v.bbbb.oovv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp345 = einsum(v.aabb.oooo, (0, 1, 2, 3), t1.aa, (1, 4), (0, 2, 3, 4)) + tmp343 = einsum(t1.bb, (0, 1), v.bbbb.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp342 = einsum(v.aabb.vvov, (0, 1, 2, 3), t1.aa, (4, 1), (4, 2, 0, 3)) + tmp340 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t1.bb, (4, 1), (4, 0, 2, 3)) + tmp335 = einsum(t2.bbbb, (0, 1, 2, 3), f.bb.ov, (4, 3), (4, 0, 1, 2)) + tmp333 = einsum(t2.abab, (0, 1, 2, 3), f.bb.ov, (4, 3), (0, 4, 1, 2)) + tmp317 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 5, 3), (1, 5, 2, 4)) + tmp315 = einsum(t2.bbbb, (0, 1, 2, 3), v.aabb.ovov, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp313 = einsum(v.aabb.ovov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp312 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovov, (4, 2, 0, 5), (4, 1, 5, 3)) + tmp310 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 1), (4, 0, 5, 3)) + tmp309 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovov, (4, 5, 0, 2), (4, 1, 5, 3)) + tmp307 = einsum(v.aaaa.ovov, (0, 1, 2, 3), t2.aaaa, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp305 = einsum(tmp156, (0, 1, 2, 3), t2.abab, (0, 2, 4, 5), (1, 4, 3, 5)) + tmp303 = einsum(t2.aaaa, (0, 1, 2, 3), tmp46, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 + tmp296 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 5, 3), (4, 5, 1, 2)) + tmp294 = einsum(v.aabb.vvov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (4, 0, 1, 5)) + tmp292 = einsum(v.aabb.vvov, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (4, 5, 0, 1)) + tmp291 = einsum(t2.abab, (0, 1, 2, 3), v.aaaa.ovvv, (0, 4, 5, 2), (1, 4, 5, 3)) + tmp289 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) + tmp288 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 5), (4, 2, 3, 5)) + tmp286 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), t2.aaaa, (4, 0, 5, 1), (4, 5, 2, 3)) + tmp284 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovoo, (0, 4, 5, 1), (5, 2, 4, 3)) + tmp282 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ooov, (4, 1, 0, 5), (4, 2, 3, 5)) * -1 + tmp280 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 4, 1, 3), (2, 4)) + tmp278 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovov, (0, 3, 1, 4), (2, 4)) * -1 + tmp276 = einsum(t1.bb, (0, 1), v.aabb.vvvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp274 = einsum(v.aaaa.vvvv, (0, 1, 2, 3), t1.aa, (4, 3), (4, 0, 1, 2)) + tmp266 = einsum(t1.bb, (0, 1), tmp265, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp263 = einsum(t1.aa, (0, 1), tmp262, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp261 = einsum(t1.bb, (0, 1), tmp260, (2, 0), (2, 1)) + tmp258 = einsum(tmp208, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp257 = einsum(t1.bb, (0, 1), tmp256, (2, 0), (2, 1)) + tmp255 = einsum(t1.bb, (0, 1), tmp254, (2, 0), (2, 1)) + tmp252 = einsum(tmp207, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp250 = einsum(tmp206, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp248 = einsum(tmp247, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp245 = einsum(tmp31, (0, 1, 2, 3), t1.aa, (4, 2), (4, 0, 1, 3)) + tmp243 = einsum(tmp242, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp241 = einsum(tmp240, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp239 = einsum(tmp238, (0, 1), t1.bb, (2, 0), (2, 1)) + tmp237 = einsum(tmp236, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp234 = einsum(t1.aa, (0, 1), tmp233, (1, 2), (0, 2)) + tmp231 = einsum(tmp230, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp229 = einsum(t1.bb, (0, 1), tmp228, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp227 = einsum(t1.bb, (0, 1), tmp226, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp224 = einsum(t1.aa, (0, 1), tmp221, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp222 = einsum(t1.aa, (0, 1), tmp221, (2, 3, 0, 4), (2, 3, 4, 1)) + tmp220 = einsum(t1.bb, (0, 1), tmp219, (2, 0), (2, 1)) + tmp217 = einsum(tmp27, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp216 = einsum(t1.bb, (0, 1), tmp215, (2, 0), (2, 1)) + tmp214 = einsum(tmp213, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp211 = einsum(tmp26, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp209 = einsum(tmp25, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp190 = einsum(t1.bb, (0, 1), tmp189, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp187 = einsum(tmp186, (0, 1, 2, 3), t1.aa, (3, 4), (0, 1, 2, 4)) + tmp184 = einsum(tmp54, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp182 = einsum(tmp181, (0, 1), t1.bb, (1, 2), (0, 2)) + tmp179 = einsum(t1.bb, (0, 1), tmp178, (2, 0), (2, 1)) + tmp176 = einsum(tmp52, (0, 1), t1.aa, (1, 2), (0, 2)) + tmp169 = einsum(t2.abab, (0, 1, 2, 3), tmp156, (4, 5, 1, 2), (0, 4, 5, 3)) + tmp167 = einsum(tmp50, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp165 = einsum(tmp50, (0, 1, 2, 3), t2.abab, (4, 2, 5, 3), (0, 4, 1, 5)) + tmp164 = einsum(tmp46, (0, 1, 2, 3), t2.abab, (2, 4, 3, 5), (0, 1, 4, 5)) + tmp162 = einsum(t2.aaaa, (0, 1, 2, 3), tmp46, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp161 = einsum(tmp46, (0, 1, 2, 3), t2.abab, (1, 4, 3, 5), (0, 2, 4, 5)) + tmp159 = einsum(tmp46, (0, 1, 2, 3), t2.aaaa, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp157 = einsum(tmp156, (0, 1, 2, 3), t2.abab, (0, 2, 3, 4), (1, 4)) + tmp154 = einsum(tmp50, (0, 1, 2, 3), t2.abab, (1, 2, 4, 3), (0, 4)) + tmp152 = einsum(t2.bbbb, (0, 1, 2, 3), tmp151, (4, 1, 0, 3), (4, 2)) + tmp149 = einsum(t2.aaaa, (0, 1, 2, 3), tmp46, (4, 0, 1, 3), (4, 2)) * -1 + tmp147 = einsum(t2.abab, (0, 1, 2, 3), tmp44, (4, 2), (0, 4, 1, 3)) + tmp145 = einsum(tmp44, (0, 1), t2.aaaa, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp143 = einsum(tmp37, (0, 1), t2.abab, (2, 3, 1, 4), (2, 0, 3, 4)) + tmp141 = einsum(t2.aaaa, (0, 1, 2, 3), tmp37, (4, 3), (0, 1, 4, 2)) + tmp139 = einsum(tmp114, (0, 1), t2.abab, (2, 3, 1, 4), (2, 0, 3, 4)) + tmp137 = einsum(t2.aaaa, (0, 1, 2, 3), tmp114, (4, 3), (0, 1, 4, 2)) + tmp135 = einsum(tmp43, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp133 = einsum(tmp43, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp132 = einsum(tmp44, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp130 = einsum(tmp44, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp128 = einsum(tmp41, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp126 = einsum(tmp41, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp124 = einsum(tmp121, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp122 = einsum(t2.abab, (0, 1, 2, 3), tmp121, (1, 3), (0, 2)) + tmp120 = einsum(tmp37, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp118 = einsum(tmp37, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp117 = einsum(tmp114, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp115 = einsum(tmp114, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp102 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (4, 5, 1, 3), (4, 0, 5, 2)) + tmp100 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), t2.aaaa, (4, 5, 3, 1), (4, 5, 0, 2)) * -1 + tmp98 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.vvov, (4, 2, 1, 3), (0, 4)) + tmp96 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t2.abab, (0, 4, 1, 3), (4, 2)) + tmp94 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), t2.bbbb, (4, 0, 1, 3), (4, 2)) + tmp92 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ovvv, (1, 3, 4, 2), (0, 4)) * -1 + tmp80 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.bbbb, (4, 2, 5, 3), (0, 1, 4, 5)) + tmp78 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ooov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp77 = einsum(t2.abab, (0, 1, 2, 3), v.aabb.ovoo, (4, 2, 5, 1), (0, 4, 5, 3)) + tmp76 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.abab, (2, 4, 3, 5), (0, 1, 4, 5)) + tmp74 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ooov, (4, 5, 1, 3), (0, 4, 5, 2)) + tmp73 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.abab, (1, 4, 3, 5), (0, 2, 4, 5)) + tmp71 = einsum(t2.aaaa, (0, 1, 2, 3), v.aaaa.ooov, (4, 1, 5, 3), (0, 4, 5, 2)) + tmp69 = einsum(v.aabb.ooov, (0, 1, 2, 3), t2.abab, (1, 2, 4, 3), (0, 4)) + tmp67 = einsum(v.aabb.ovoo, (0, 1, 2, 3), t2.abab, (0, 3, 1, 4), (2, 4)) + tmp65 = einsum(t2.bbbb, (0, 1, 2, 3), v.bbbb.ooov, (4, 0, 1, 3), (4, 2)) + tmp63 = einsum(v.aaaa.ooov, (0, 1, 2, 3), t2.aaaa, (2, 1, 4, 3), (0, 4)) * -1 + tmp51 = einsum(t1.bb, (0, 1), v.aabb.oovv, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp48 = einsum(t1.aa, (0, 1), v.aaaa.oovv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp42 = einsum(t1.bb, (0, 1), v.bbbb.oovv, (2, 0, 3, 1), (2, 3)) + tmp39 = einsum(t1.aa, (0, 1), v.aaaa.oovv, (2, 0, 3, 1), (2, 3)) + tmp35 = einsum(t1.bb, (0, 1), v.aabb.oooo, (2, 3, 4, 0), (2, 3, 4, 1)) + tmp33 = einsum(v.aaaa.oooo, (0, 1, 2, 3), t1.aa, (3, 4), (0, 1, 2, 4)) + tmp32 = einsum(v.aabb.ovvv, (0, 1, 2, 3), t1.bb, (4, 3), (0, 4, 1, 2)) + tmp30 = einsum(t1.aa, (0, 1), v.aaaa.ovvv, (2, 1, 3, 4), (0, 2, 3, 4)) + tmp22 = einsum(t1.bb, (0, 1), tmp21, (0, 2), (2, 1)) + tmp19 = einsum(tmp1, (0, 1), t1.aa, (0, 2), (1, 2)) + tmp17 = einsum(t2.abab, (0, 1, 2, 3), f.aa.ov, (4, 2), (4, 0, 1, 3)) + tmp15 = einsum(t2.aaaa, (0, 1, 2, 3), f.aa.ov, (4, 3), (4, 0, 1, 2)) + tmp13 = einsum(f.bb.ov, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp11 = einsum(f.bb.ov, (0, 1), t2.abab, (2, 0, 3, 1), (2, 3)) + tmp10 = einsum(f.aa.ov, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp8 = einsum(f.aa.ov, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp7 = einsum(f.bb.vv, (0, 1), t1.bb, (2, 1), (2, 0)) + tmp5 = einsum(f.aa.vv, (0, 1), t1.aa, (2, 1), (2, 0)) + tmp4 = einsum(t1.bb, (0, 1), f.bb.oo, (2, 0), (2, 1)) + tmp2 = einsum(f.aa.oo, (0, 1), t1.aa, (1, 2), (0, 2)) + + return {f"tmp1": tmp1, f"tmp10": tmp10, f"tmp100": tmp100, f"tmp102": tmp102, f"tmp11": tmp11, f"tmp114": tmp114, f"tmp115": tmp115, f"tmp117": tmp117, f"tmp118": tmp118, f"tmp120": tmp120, f"tmp121": tmp121, f"tmp122": tmp122, f"tmp124": tmp124, f"tmp126": tmp126, f"tmp128": tmp128, f"tmp13": tmp13, f"tmp130": tmp130, f"tmp132": tmp132, f"tmp133": tmp133, f"tmp135": tmp135, f"tmp137": tmp137, f"tmp139": tmp139, f"tmp141": tmp141, f"tmp143": tmp143, f"tmp145": tmp145, f"tmp147": tmp147, f"tmp149": tmp149, f"tmp15": tmp15, f"tmp151": tmp151, f"tmp152": tmp152, f"tmp154": tmp154, f"tmp156": tmp156, f"tmp157": tmp157, f"tmp159": tmp159, f"tmp161": tmp161, f"tmp162": tmp162, f"tmp164": tmp164, f"tmp165": tmp165, f"tmp167": tmp167, f"tmp169": tmp169, f"tmp17": tmp17, f"tmp176": tmp176, f"tmp178": tmp178, f"tmp179": tmp179, f"tmp181": tmp181, f"tmp182": tmp182, f"tmp184": tmp184, f"tmp186": tmp186, f"tmp187": tmp187, f"tmp189": tmp189, f"tmp19": tmp19, f"tmp190": tmp190, f"tmp2": tmp2, f"tmp206": tmp206, f"tmp207": tmp207, f"tmp208": tmp208, f"tmp209": tmp209, f"tmp21": tmp21, f"tmp211": tmp211, f"tmp213": tmp213, f"tmp214": tmp214, f"tmp215": tmp215, f"tmp216": tmp216, f"tmp217": tmp217, f"tmp219": tmp219, f"tmp22": tmp22, f"tmp220": tmp220, f"tmp221": tmp221, f"tmp222": tmp222, f"tmp224": tmp224, f"tmp226": tmp226, f"tmp227": tmp227, f"tmp228": tmp228, f"tmp229": tmp229, f"tmp230": tmp230, f"tmp231": tmp231, f"tmp233": tmp233, f"tmp234": tmp234, f"tmp236": tmp236, f"tmp237": tmp237, f"tmp238": tmp238, f"tmp239": tmp239, f"tmp240": tmp240, f"tmp241": tmp241, f"tmp242": tmp242, f"tmp243": tmp243, f"tmp245": tmp245, f"tmp247": tmp247, f"tmp248": tmp248, f"tmp25": tmp25, f"tmp250": tmp250, f"tmp252": tmp252, f"tmp254": tmp254, f"tmp255": tmp255, f"tmp256": tmp256, f"tmp257": tmp257, f"tmp258": tmp258, f"tmp26": tmp26, f"tmp260": tmp260, f"tmp261": tmp261, f"tmp262": tmp262, f"tmp263": tmp263, f"tmp265": tmp265, f"tmp266": tmp266, f"tmp27": tmp27, f"tmp274": tmp274, f"tmp276": tmp276, f"tmp278": tmp278, f"tmp280": tmp280, f"tmp282": tmp282, f"tmp284": tmp284, f"tmp286": tmp286, f"tmp288": tmp288, f"tmp289": tmp289, f"tmp291": tmp291, f"tmp292": tmp292, f"tmp294": tmp294, f"tmp296": tmp296, f"tmp30": tmp30, f"tmp303": tmp303, f"tmp305": tmp305, f"tmp307": tmp307, f"tmp309": tmp309, f"tmp31": tmp31, f"tmp310": tmp310, f"tmp312": tmp312, f"tmp313": tmp313, f"tmp315": tmp315, f"tmp317": tmp317, f"tmp32": tmp32, f"tmp324": tmp324, f"tmp33": tmp33, f"tmp333": tmp333, f"tmp335": tmp335, f"tmp340": tmp340, f"tmp341": tmp341, f"tmp342": tmp342, f"tmp343": tmp343, f"tmp345": tmp345, f"tmp35": tmp35, f"tmp351": tmp351, f"tmp353": tmp353, f"tmp363": tmp363, f"tmp364": tmp364, f"tmp366": tmp366, f"tmp367": tmp367, f"tmp369": tmp369, f"tmp37": tmp37, f"tmp370": tmp370, f"tmp372": tmp372, f"tmp384": tmp384, f"tmp386": tmp386, f"tmp39": tmp39, f"tmp4": tmp4, f"tmp403": tmp403, f"tmp405": tmp405, f"tmp407": tmp407, f"tmp409": tmp409, f"tmp41": tmp41, f"tmp411": tmp411, f"tmp413": tmp413, f"tmp419": tmp419, f"tmp42": tmp42, f"tmp420": tmp420, f"tmp422": tmp422, f"tmp423": tmp423, f"tmp425": tmp425, f"tmp427": tmp427, f"tmp429": tmp429, f"tmp43": tmp43, f"tmp44": tmp44, f"tmp440": tmp440, f"tmp441": tmp441, f"tmp443": tmp443, f"tmp454": tmp454, f"tmp455": tmp455, f"tmp457": tmp457, f"tmp459": tmp459, f"tmp46": tmp46, f"tmp460": tmp460, f"tmp464": tmp464, f"tmp466": tmp466, f"tmp471": tmp471, f"tmp472": tmp472, f"tmp474": tmp474, f"tmp48": tmp48, f"tmp482": tmp482, f"tmp484": tmp484, f"tmp486": tmp486, f"tmp488": tmp488, f"tmp490": tmp490, f"tmp492": tmp492, f"tmp494": tmp494, f"tmp495": tmp495, f"tmp497": tmp497, f"tmp498": tmp498, f"tmp5": tmp5, f"tmp50": tmp50, f"tmp500": tmp500, f"tmp502": tmp502, f"tmp504": tmp504, f"tmp51": tmp51, f"tmp511": tmp511, f"tmp513": tmp513, f"tmp515": tmp515, f"tmp516": tmp516, f"tmp518": tmp518, f"tmp519": tmp519, f"tmp52": tmp52, f"tmp521": tmp521, f"tmp523": tmp523, f"tmp525": tmp525, f"tmp54": tmp54, f"tmp63": tmp63, f"tmp65": tmp65, f"tmp67": tmp67, f"tmp69": tmp69, f"tmp7": tmp7, f"tmp71": tmp71, f"tmp73": tmp73, f"tmp74": tmp74, f"tmp76": tmp76, f"tmp77": tmp77, f"tmp78": tmp78, f"tmp8": tmp8, f"tmp80": tmp80, f"tmp92": tmp92, f"tmp94": tmp94, f"tmp96": tmp96, f"tmp98": tmp98} + +def hbar_lmatvec_ee(f=None, r1=None, r2=None, t1=None, t2=None, v=None, **kwargs): + """ + Code generated by `albert` 0.0.0 on 2024-08-13T22:30:27.131599. + + Parameters + ---------- + f : Namespace of arrays + Fock matrix. + r1 : Namespace of arrays + R1 amplitudes. + r2 : Namespace of arrays + R2 amplitudes. + t1 : Namespace of arrays + T1 amplitudes. + t2 : Namespace of arrays + T2 amplitudes. + v : Namespace of arrays + Electron repulsion integrals. + + Returns + ------- + r1new : Namespace of arrays + Updated R1 residuals. + r2new : Namespace of arrays + Updated R2 residuals. + """ + + ints = kwargs["ints"] + r1new = Namespace() + r2new = Namespace() + tmp27 = einsum(r2.abab, (0, 1, 2, 3), t2.abab, (0, 1, 2, 4), (3, 4)) + tmp28 = einsum(t2.bbbb, (0, 1, 2, 3), r2.bbbb, (0, 1, 4, 3), (4, 2)) + tmp45 = einsum(t2.bbbb, (0, 1, 2, 3), r2.bbbb, (4, 1, 2, 3), (4, 0)) + tmp44 = einsum(r2.abab, (0, 1, 2, 3), t2.abab, (0, 4, 2, 3), (1, 4)) + tmp38 = einsum(r2.aaaa, (0, 1, 2, 3), t2.aaaa, (4, 1, 2, 3), (0, 4)) + tmp39 = einsum(r2.abab, (0, 1, 2, 3), t2.abab, (4, 1, 2, 3), (0, 4)) + tmp17 = einsum(t2.aaaa, (0, 1, 2, 3), r2.aaaa, (0, 1, 4, 3), (4, 2)) + tmp18 = einsum(t2.abab, (0, 1, 2, 3), r2.abab, (0, 1, 4, 3), (4, 2)) + tmp33 = einsum(r2.bbbb, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp128 = ints.tmp41.copy() + tmp128 += ints.tmp43 + tmp7 = einsum(r2.abab, (0, 1, 2, 3), t1.aa, (4, 2), (0, 4, 1, 3)) + tmp138 = ints.tmp340.copy() * 0.5 + tmp138 += ints.tmp519.transpose((0, 1, 3, 2)) + tmp144 = tmp27.copy() * 0.5 + tmp144 += tmp28 + tmp142 = ints.tmp151.copy() * -1 + tmp142 += ints.tmp151.transpose((0, 2, 1, 3)) + tmp47 = tmp44.copy() * 0.5 + tmp47 += tmp45 + tmp140 = v.bbbb.ooov.copy() * -1 + tmp140 += v.bbbb.ooov.transpose((0, 2, 1, 3)) + tmp159 = ints.tmp342.copy() + tmp159 += ints.tmp515 + tmp159 += ints.tmp521 * 2 + tmp0 = einsum(t1.bb, (0, 1), r1.bb, (2, 1), (2, 0)) + tmp161 = ints.tmp341.copy() + tmp161 += ints.tmp523.transpose((0, 1, 3, 2)) + tmp161 += ints.tmp516.transpose((0, 1, 3, 2)) * 2 + tmp9 = einsum(r2.abab, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp5 = einsum(t1.aa, (0, 1), r2.aaaa, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp94 = ints.tmp309.copy() + tmp94 += ints.tmp32 + tmp94 += ints.tmp315 * 2 + tmp92 = ints.tmp313.copy() + tmp92 += ints.tmp31.transpose((0, 1, 3, 2)) + tmp92 += ints.tmp307 * 2 + tmp37 = einsum(r1.aa, (0, 1), t1.aa, (2, 1), (0, 2)) + tmp86 = tmp38.copy() * 2 + tmp86 += tmp39 + tmp79 = ints.tmp30.copy() * 0.5 + tmp79 += ints.tmp310.transpose((0, 1, 3, 2)) + tmp84 = tmp17.copy() * 2 + tmp84 += tmp18 + tmp43 = ints.tmp46.copy() * -1 + tmp43 += ints.tmp46.transpose((0, 2, 1, 3)) + tmp81 = v.aaaa.ooov.copy() + tmp81 += v.aaaa.ooov.transpose((0, 2, 1, 3)) * -1 + tmp152 = f.bb.vv.copy() + tmp152 += ints.tmp236 + tmp152 += ints.tmp240 + tmp148 = f.bb.oo.copy() + tmp148 += ints.tmp178 * 2 + tmp148 += ints.tmp181 + tmp148 += ints.tmp215 + tmp148 += ints.tmp219 + tmp148 += ints.tmp21.transpose((1, 0)) + tmp148 += ints.tmp256 + tmp148 += ints.tmp260 + tmp129 = einsum(tmp128, (0, 1), tmp33, (2, 3, 0, 4), (2, 3, 1, 4)) * 2 + del tmp128 + tmp127 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), tmp33, (4, 5, 0, 3), (5, 4, 1, 2)) + tmp59 = einsum(tmp33, (0, 1, 2, 3), t1.bb, (4, 3), (0, 1, 4, 2)) + tmp134 = einsum(ints.tmp518, (0, 1, 2, 3), r2.abab, (0, 4, 2, 5), (1, 4, 3, 5)) + tmp132 = einsum(r1.bb, (0, 1), v.bbbb.ooov, (2, 0, 3, 4), (2, 3, 1, 4)) + tmp133 = einsum(v.bbbb.ovvv, (0, 1, 2, 3), r1.bb, (4, 3), (4, 0, 1, 2)) + tmp136 = einsum(ints.tmp50, (0, 1, 2, 3), tmp7, (0, 1, 4, 5), (2, 4, 3, 5)) + tmp137 = einsum(v.aabb.ooov, (0, 1, 2, 3), tmp7, (1, 0, 4, 5), (4, 2, 5, 3)) + tmp139 = einsum(r2.bbbb, (0, 1, 2, 3), tmp138, (1, 4, 5, 3), (4, 0, 5, 2)) * 4 + del tmp138 + tmp131 = einsum(r1.bb, (0, 1), ints.tmp151, (0, 2, 3, 4), (2, 3, 4, 1)) + tmp145 = einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp144, (4, 1), (0, 2, 4, 3)) * 2 + del tmp144 + tmp135 = einsum(r2.bbbb, (0, 1, 2, 3), v.bbbb.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp143 = einsum(tmp33, (0, 1, 2, 3), tmp142, (0, 2, 4, 5), (4, 1, 5, 3)) * 2 + del tmp142 + tmp146 = einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp47, (4, 2), (4, 0, 3, 1)) * 2 + tmp141 = einsum(tmp33, (0, 1, 2, 3), tmp140, (0, 2, 4, 5), (4, 1, 5, 3)) * 2 + del tmp140 + tmp154 = ints.tmp238.copy() * 0.5 + tmp154 += ints.tmp486.transpose((1, 0)) + tmp154 += ints.tmp488.transpose((1, 0)) * 0.5 + tmp160 = einsum(tmp159, (0, 1, 2, 3), r2.abab, (0, 4, 2, 5), (1, 4, 3, 5)) + del tmp159 + tmp158 = einsum(tmp0, (0, 1), v.bbbb.ovov, (2, 3, 1, 4), (0, 2, 3, 4)) + tmp162 = einsum(tmp161, (0, 1, 2, 3), r2.bbbb, (4, 0, 5, 3), (1, 4, 2, 5)) + del tmp161 + tmp156 = einsum(r2.abab, (0, 1, 2, 3), v.aabb.ovov, (0, 2, 4, 5), (1, 4, 3, 5)) + tmp157 = einsum(v.bbbb.ovov, (0, 1, 2, 3), r2.bbbb, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp164 = f.bb.ov.copy() + tmp164 += ints.tmp121 * -1 + tmp150 = ints.tmp213.copy() + tmp150 += ints.tmp254 + tmp11 = einsum(tmp9, (0, 1, 2, 3), t1.aa, (4, 3), (0, 4, 1, 2)) + tmp100 = einsum(v.aaaa.ovvv, (0, 1, 2, 3), tmp5, (4, 5, 0, 3), (5, 4, 1, 2)) + tmp99 = einsum(ints.tmp114, (0, 1), tmp5, (2, 3, 0, 4), (2, 3, 1, 4)) + tmp95 = einsum(tmp94, (0, 1, 2, 3), r2.abab, (4, 1, 5, 3), (0, 4, 2, 5)) + del tmp94 + tmp89 = einsum(v.aaaa.ovov, (0, 1, 2, 3), r2.aaaa, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp93 = einsum(tmp92, (0, 1, 2, 3), r2.aaaa, (4, 0, 5, 2), (1, 4, 3, 5)) + del tmp92 + tmp91 = einsum(v.aabb.ovov, (0, 1, 2, 3), r2.abab, (4, 2, 5, 3), (4, 0, 5, 1)) + tmp90 = einsum(v.aaaa.ovov, (0, 1, 2, 3), tmp37, (4, 2), (4, 0, 1, 3)) + tmp13 = einsum(t1.aa, (0, 1), tmp5, (2, 3, 4, 1), (2, 3, 0, 4)) + tmp87 = einsum(v.aaaa.ovov, (0, 1, 2, 3), tmp86, (4, 2), (4, 0, 3, 1)) + del tmp86 + tmp74 = einsum(r1.aa, (0, 1), v.aaaa.ovvv, (2, 3, 4, 1), (0, 2, 3, 4)) + tmp75 = einsum(r2.aaaa, (0, 1, 2, 3), v.aaaa.oovv, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp80 = einsum(tmp79, (0, 1, 2, 3), r2.aaaa, (4, 0, 5, 3), (1, 4, 2, 5)) * 4 + del tmp79 + tmp73 = einsum(r1.aa, (0, 1), v.aaaa.ooov, (2, 0, 3, 4), (2, 3, 1, 4)) + tmp85 = einsum(tmp84, (0, 1), v.aaaa.ovov, (2, 1, 3, 4), (2, 3, 0, 4)) + tmp83 = einsum(tmp43, (0, 1, 2, 3), tmp5, (0, 4, 1, 5), (4, 2, 5, 3)) * 2 + tmp77 = einsum(ints.tmp156, (0, 1, 2, 3), tmp9, (4, 1, 2, 5), (0, 4, 3, 5)) + tmp76 = einsum(ints.tmp312, (0, 1, 2, 3), r2.abab, (4, 1, 5, 3), (0, 4, 2, 5)) + tmp82 = einsum(tmp81, (0, 1, 2, 3), tmp5, (0, 4, 2, 5), (1, 4, 3, 5)) * 2 + del tmp81 + tmp78 = einsum(v.aabb.ovoo, (0, 1, 2, 3), tmp9, (4, 3, 2, 5), (4, 0, 5, 1)) + tmp72 = einsum(r1.aa, (0, 1), ints.tmp46, (0, 2, 3, 4), (2, 3, 4, 1)) + tmp106 = f.aa.oo.copy() * 0.5 + tmp106 += ints.tmp1.transpose((1, 0)) * 0.5 + tmp106 += ints.tmp207 * 0.5 + tmp106 += ints.tmp208 * 0.5 + tmp106 += ints.tmp26 * 0.5 + tmp106 += ints.tmp27 * 0.5 + tmp106 += ints.tmp52 + tmp106 += ints.tmp54 * 0.5 + tmp104 = ints.tmp233.copy() * 0.5 + tmp104 += ints.tmp278.transpose((1, 0)) + tmp104 += ints.tmp280.transpose((1, 0)) * 0.5 + tmp102 = f.aa.vv.copy() + tmp102 += ints.tmp230 + tmp102 += ints.tmp242 + tmp97 = f.aa.ov.copy() + tmp97 += ints.tmp37 + tmp97 += ints.tmp44 + tmp108 = ints.tmp206.copy() + tmp108 += ints.tmp25 + tmp23 = einsum(t2.aaaa, (0, 1, 2, 3), tmp5, (1, 0, 4, 3), (4, 2)) + tmp21 = einsum(r1.aa, (0, 1), t2.aaaa, (2, 0, 3, 1), (2, 3)) + tmp24 = einsum(tmp7, (0, 1, 2, 3), t2.abab, (0, 2, 4, 3), (1, 4)) + tmp22 = einsum(t2.abab, (0, 1, 2, 3), r1.bb, (1, 3), (0, 2)) + tmp34 = einsum(t2.bbbb, (0, 1, 2, 3), tmp33, (1, 0, 4, 3), (4, 2)) + tmp32 = einsum(t2.abab, (0, 1, 2, 3), tmp9, (0, 1, 4, 2), (4, 3)) + tmp30 = einsum(r1.aa, (0, 1), t2.abab, (0, 2, 1, 3), (2, 3)) + tmp31 = einsum(r1.bb, (0, 1), t2.bbbb, (2, 0, 3, 1), (2, 3)) + tmp153 = einsum(tmp152, (0, 1), r2.bbbb, (2, 3, 4, 0), (2, 3, 1, 4)) * -1 + del tmp152 + tmp149 = einsum(tmp148, (0, 1), r2.bbbb, (2, 0, 3, 4), (1, 2, 3, 4)) * -2 + del tmp148 + tmp70 = f.bb.ov.copy() + tmp70 += ints.tmp41 + tmp70 += ints.tmp43 + tmp70 += ints.tmp121 * -1 + tmp166 = ints.tmp440.copy() + tmp166 += ints.tmp471 + tmp166 += v.bbbb.oooo.transpose((0, 2, 3, 1)) * -1 + tmp166 += ints.tmp454.transpose((1, 0, 2, 3)) + tmp166 += ints.tmp454.transpose((1, 0, 3, 2)) * -1 + tmp130 = tmp127.copy() * -2 + del tmp127 + tmp130 += tmp129.transpose((1, 0, 2, 3)) * -1 + del tmp129 + tmp167 = einsum(r2.bbbb, (0, 1, 2, 3), t2.bbbb, (4, 5, 2, 3), (0, 1, 4, 5)) + tmp167 += tmp59.transpose((0, 1, 3, 2)) * -1 + tmp147 = tmp131.copy() + del tmp131 + tmp147 += tmp132 + del tmp132 + tmp147 += tmp133 + del tmp133 + tmp147 += tmp134 + del tmp134 + tmp147 += tmp135 * 2 + del tmp135 + tmp147 += tmp136 + del tmp136 + tmp147 += tmp137 + del tmp137 + tmp147 += tmp139 + del tmp139 + tmp147 += tmp141.transpose((1, 0, 3, 2)) + del tmp141 + tmp147 += tmp143 * -1 + del tmp143 + tmp147 += tmp145.transpose((1, 0, 2, 3)) * -1 + del tmp145 + tmp147 += tmp146.transpose((0, 1, 3, 2)) * -1 + del tmp146 + tmp155 = einsum(r2.bbbb, (0, 1, 2, 3), tmp154, (4, 3), (0, 1, 4, 2)) * -4 + del tmp154 + tmp163 = tmp156.copy() + del tmp156 + tmp163 += tmp157 * 2 + del tmp157 + tmp163 += tmp158 + del tmp158 + tmp163 += tmp160 + del tmp160 + tmp163 += tmp162 * 2 + del tmp162 + tmp165 = einsum(tmp164, (0, 1), tmp33, (2, 3, 0, 4), (2, 3, 1, 4)) + del tmp164 + tmp151 = einsum(tmp150, (0, 1), r2.bbbb, (2, 0, 3, 4), (1, 2, 3, 4)) * -1 + del tmp150 + tmp10 = ints.tmp324.transpose((0, 1, 3, 2)).copy() + tmp10 += v.aabb.vvoo.transpose((2, 3, 0, 1)) + tmp10 += ints.tmp317 * -1 + tmp58 = ints.tmp50.copy() + tmp58 += v.aabb.ooov + tmp49 = f.aa.ov.copy() + tmp49 += ints.tmp37 + tmp49 += ints.tmp44 + tmp49 += ints.tmp114 * -1 + tmp122 = ints.tmp233.transpose((1, 0)).copy() + tmp122 += ints.tmp278 * 2 + tmp122 += ints.tmp280 + tmp122 += f.aa.vv * -1 + tmp122 += ints.tmp230 * -1 + tmp122 += ints.tmp242 * -1 + tmp125 = f.bb.oo.copy() + tmp125 += ints.tmp178 * 2 + tmp125 += ints.tmp181 + tmp125 += ints.tmp215 + tmp125 += ints.tmp219 + tmp125 += ints.tmp21.transpose((1, 0)) + tmp125 += ints.tmp256 + tmp125 += ints.tmp260 + tmp125 += ints.tmp213 * -1 + tmp125 += ints.tmp254 * -1 + tmp120 = ints.tmp156.copy() + tmp120 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp29 = tmp27.copy() + del tmp27 + tmp29 += tmp28 * 2 + del tmp28 + tmp116 = ints.tmp189.copy() + tmp116 += ints.tmp226 + tmp116 += ints.tmp228.transpose((1, 0, 2, 3)) + tmp116 += ints.tmp265 + tmp116 += v.aabb.oooo + tmp113 = ints.tmp307.copy() * 2 + tmp113 += ints.tmp313 + tmp113 += ints.tmp31.transpose((0, 1, 3, 2)) + tmp113 += v.aaaa.ovov.transpose((0, 2, 1, 3)) + tmp113 += ints.tmp30.transpose((0, 1, 3, 2)) * -1 + tmp113 += ints.tmp310 * -2 + tmp113 += v.aaaa.oovv * -1 + tmp115 = ints.tmp247.copy() + tmp115 += v.aabb.oovv + tmp115 += ints.tmp525 * -1 + tmp119 = einsum(r2.abab, (0, 1, 2, 3), t2.abab, (4, 5, 2, 3), (0, 4, 1, 5)) + tmp119 += tmp11 + tmp126 = tmp37.copy() + tmp126 += tmp38 * 2 + tmp126 += tmp39 + tmp8 = ints.tmp309.copy() + tmp8 += ints.tmp315 * 2 + tmp8 += ints.tmp32 + tmp8 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp8 += ints.tmp312 * -1 + tmp118 = ints.tmp46.copy() + tmp118 += ints.tmp46.transpose((0, 2, 1, 3)) * -1 + tmp118 += v.aaaa.ooov * -1 + tmp118 += v.aaaa.ooov.transpose((0, 2, 1, 3)) + tmp124 = f.aa.oo.copy() + tmp124 += ints.tmp1.transpose((1, 0)) + tmp124 += ints.tmp207 + tmp124 += ints.tmp208 + tmp124 += ints.tmp26 + tmp124 += ints.tmp27 + tmp124 += ints.tmp52 * 2 + tmp124 += ints.tmp54 + tmp124 += ints.tmp206 * -1 + tmp124 += ints.tmp25 * -1 + tmp46 = tmp0.copy() + tmp46 += tmp44 + tmp46 += tmp45 * 2 + tmp121 = ints.tmp50.copy() + tmp121 += v.aabb.ooov + tmp12 = ints.tmp156.copy() + tmp12 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp123 = ints.tmp238.transpose((1, 0)).copy() + tmp123 += ints.tmp486 * 2 + tmp123 += ints.tmp488 + tmp123 += f.bb.vv * -1 + tmp123 += ints.tmp236 * -1 + tmp123 += ints.tmp240 * -1 + tmp112 = ints.tmp341.copy() + tmp112 += ints.tmp516.transpose((0, 1, 3, 2)) * 2 + tmp112 += ints.tmp523.transpose((0, 1, 3, 2)) + tmp112 += v.bbbb.ovov.transpose((0, 2, 3, 1)) + tmp112 += ints.tmp340 * -1 + tmp112 += ints.tmp519.transpose((0, 1, 3, 2)) * -2 + tmp112 += v.bbbb.oovv * -1 + tmp114 = ints.tmp342.copy() * 0.5 + tmp114 += ints.tmp515 * 0.5 + tmp114 += ints.tmp521 + tmp114 += v.aabb.ovov.transpose((0, 2, 1, 3)) * 0.5 + tmp114 += ints.tmp518 * -0.5 + tmp117 = ints.tmp151.copy() * -1 + tmp117 += ints.tmp151.transpose((0, 2, 1, 3)) + tmp117 += v.bbbb.ooov + tmp117 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -1 + tmp101 = tmp99.copy() * 2 + del tmp99 + tmp101 += tmp100 * 2 + del tmp100 + tmp96 = tmp89.copy() * 2 + del tmp89 + tmp96 += tmp90 + del tmp90 + tmp96 += tmp91 + del tmp91 + tmp96 += tmp93 * 2 + del tmp93 + tmp96 += tmp95 + del tmp95 + tmp111 = einsum(t2.aaaa, (0, 1, 2, 3), r2.aaaa, (4, 5, 2, 3), (4, 5, 0, 1)) + tmp111 += tmp13.transpose((0, 1, 3, 2)) * -1 + tmp88 = tmp72.copy() + del tmp72 + tmp88 += tmp73 + del tmp73 + tmp88 += tmp74 + del tmp74 + tmp88 += tmp75 * 2 + del tmp75 + tmp88 += tmp76 + del tmp76 + tmp88 += tmp77 + del tmp77 + tmp88 += tmp78 + del tmp78 + tmp88 += tmp80 + del tmp80 + tmp88 += tmp82.transpose((1, 0, 3, 2)) + del tmp82 + tmp88 += tmp83.transpose((1, 0, 3, 2)) * -1 + del tmp83 + tmp88 += tmp85.transpose((1, 0, 2, 3)) * -1 + del tmp85 + tmp88 += tmp87.transpose((0, 1, 3, 2)) * -1 + del tmp87 + tmp107 = einsum(tmp106, (0, 1), r2.aaaa, (2, 0, 3, 4), (1, 2, 3, 4)) * -4 + del tmp106 + tmp105 = einsum(r2.aaaa, (0, 1, 2, 3), tmp104, (4, 3), (0, 1, 4, 2)) * -4 + del tmp104 + tmp103 = einsum(tmp102, (0, 1), r2.aaaa, (2, 3, 4, 0), (2, 3, 1, 4)) * -1 + del tmp102 + tmp98 = einsum(tmp97, (0, 1), tmp5, (2, 3, 0, 4), (2, 3, 1, 4)) + del tmp97 + tmp109 = einsum(tmp108, (0, 1), r2.aaaa, (2, 0, 3, 4), (1, 2, 3, 4)) * -1 + del tmp108 + tmp110 = ints.tmp186.copy() + tmp110 += ints.tmp262 + tmp110 += v.aaaa.oooo.transpose((0, 2, 3, 1)) * -1 + tmp110 += ints.tmp221 * -1 + tmp110 += ints.tmp221.transpose((0, 1, 3, 2)) + tmp51 = ints.tmp484.copy() + tmp51 += ints.tmp492.transpose((0, 1, 3, 2)) + tmp51 += ints.tmp494 + tmp51 += ints.tmp500 * 2 + tmp51 += ints.tmp513.transpose((0, 1, 3, 2)) + tmp51 += v.aabb.ovvv + tmp51 += ints.tmp497 * -1 + tmp51 += ints.tmp504.transpose((0, 1, 3, 2)) * -1 + tmp61 = ints.tmp115.copy() * 2 + tmp61 += ints.tmp122 + tmp61 += ints.tmp149 * 2 + tmp61 += ints.tmp154 + tmp61 += ints.tmp176 * 2 + tmp61 += ints.tmp184 + tmp61 += ints.tmp19 + tmp61 += ints.tmp211 + tmp61 += ints.tmp217 + tmp61 += ints.tmp234 + tmp61 += ints.tmp252 + tmp61 += ints.tmp258 + tmp61 += ints.tmp2 + tmp61 += ints.tmp39 + tmp61 += ints.tmp63 * 2 + tmp61 += ints.tmp69 + tmp61 += ints.tmp92 * 2 + tmp61 += f.aa.ov * -1 + tmp61 += ints.tmp118 * -2 + tmp61 += ints.tmp11 * -1 + tmp61 += ints.tmp126 * -1 + tmp61 += ints.tmp130 * -2 + tmp61 += ints.tmp133 * -1 + tmp61 += ints.tmp209 * -1 + tmp61 += ints.tmp231 * -1 + tmp61 += ints.tmp243 * -1 + tmp61 += ints.tmp250 * -1 + tmp61 += ints.tmp37 * -1 + tmp61 += ints.tmp44 * -1 + tmp61 += ints.tmp5 * -1 + tmp61 += ints.tmp8 * -2 + tmp61 += ints.tmp98 * -1 + tmp71 = f.bb.oo.copy() + tmp71 += ints.tmp178 * 2 + tmp71 += ints.tmp181 + tmp71 += ints.tmp215.transpose((1, 0)) + tmp71 += ints.tmp219.transpose((1, 0)) + tmp71 += ints.tmp21.transpose((1, 0)) + tmp71 += ints.tmp256 + tmp71 += ints.tmp260 + tmp71 += ints.tmp213 * -1 + tmp71 += ints.tmp254 * -1 + tmp69 = ints.tmp238.transpose((1, 0)).copy() + tmp69 += ints.tmp486 * 2 + tmp69 += ints.tmp488 + tmp69 += f.bb.vv * -1 + tmp69 += ints.tmp236.transpose((1, 0)) * -1 + tmp69 += ints.tmp240.transpose((1, 0)) * -1 + tmp52 = ints.tmp490.transpose((0, 3, 1, 2)).copy() * 0.5 + tmp52 += ints.tmp495.transpose((0, 2, 1, 3)) + tmp52 += ints.tmp502.transpose((0, 2, 1, 3)) * 0.5 + tmp52 += v.bbbb.ovvv.transpose((0, 2, 1, 3)) * 0.5 + tmp52 += ints.tmp482 * -0.5 + tmp52 += ints.tmp498.transpose((0, 2, 1, 3)) * -1 + tmp52 += ints.tmp511.transpose((0, 3, 1, 2)) * -0.5 + tmp55 = ints.tmp341.copy() * 0.5 + tmp55 += ints.tmp516.transpose((0, 1, 3, 2)) + tmp55 += ints.tmp523.transpose((0, 1, 3, 2)) * 0.5 + tmp55 += v.bbbb.ovov.transpose((0, 2, 3, 1)) * 0.5 + tmp55 += ints.tmp340 * -0.5 + tmp55 += ints.tmp519.transpose((0, 1, 3, 2)) * -1 + tmp55 += v.bbbb.oovv * -0.5 + tmp64 = v.bbbb.ovov.transpose((0, 2, 3, 1)).copy() + tmp64 += v.bbbb.ovov.transpose((0, 2, 1, 3)) * -1 + tmp67 = ints.tmp151.copy() + tmp67 += ints.tmp151.transpose((0, 2, 1, 3)) * -1 + tmp67 += v.bbbb.ooov * -1 + tmp67 += v.bbbb.ooov.transpose((0, 2, 1, 3)) + tmp16 = ints.tmp117.copy() + tmp16 += ints.tmp124 * 2 + tmp16 += ints.tmp152 * 2 + tmp16 += ints.tmp157 + tmp16 += ints.tmp179 * 2 + tmp16 += ints.tmp182 + tmp16 += ints.tmp216 + tmp16 += ints.tmp220 + tmp16 += ints.tmp22 + tmp16 += ints.tmp239 + tmp16 += ints.tmp257 + tmp16 += ints.tmp261 + tmp16 += ints.tmp42 + tmp16 += ints.tmp4 + tmp16 += ints.tmp65 * 2 + tmp16 += ints.tmp67 + tmp16 += ints.tmp94 * 2 + tmp16 += f.bb.ov * -1 + tmp16 += ints.tmp10 * -1 + tmp16 += ints.tmp120 * -1 + tmp16 += ints.tmp128 * -2 + tmp16 += ints.tmp132 * -1 + tmp16 += ints.tmp135 * -2 + tmp16 += ints.tmp13 * -2 + tmp16 += ints.tmp214 * -1 + tmp16 += ints.tmp237 * -1 + tmp16 += ints.tmp241 * -1 + tmp16 += ints.tmp255 * -1 + tmp16 += ints.tmp41 * -1 + tmp16 += ints.tmp43 * -1 + tmp16 += ints.tmp7 * -1 + tmp16 += ints.tmp96 * -1 + tmp56 = ints.tmp342.copy() + tmp56 += ints.tmp515 + tmp56 += ints.tmp521 * 2 + tmp56 += v.aabb.ovov.transpose((0, 2, 1, 3)) + tmp56 += ints.tmp518 * -1 + tmp60 = ints.tmp151.copy() + tmp60 += v.bbbb.ooov * -1 + tmp40 = tmp37.copy() * 0.5 + tmp40 += tmp38 + tmp40 += tmp39 * 0.5 + tmp42 = tmp38.copy() + del tmp38 + tmp42 += tmp39 * 0.5 + del tmp39 + tmp65 = r1.aa.copy() + tmp65 += tmp21 * 2 + tmp65 += tmp22 + tmp65 += tmp23 * -2 + tmp65 += tmp24 * -1 + tmp68 = ints.tmp340.copy() + tmp68 += v.bbbb.oovv + tmp68 += ints.tmp341 * -1 + tmp68 += v.bbbb.ovov.transpose((0, 2, 3, 1)) * -1 + tmp54 = ints.tmp335.transpose((1, 2, 0, 3)).copy() + tmp54 += ints.tmp343.transpose((1, 2, 0, 3)) + tmp54 += ints.tmp351.transpose((0, 2, 1, 3)) + tmp54 += ints.tmp367.transpose((0, 2, 1, 3)) * 2 + tmp54 += ints.tmp372.transpose((0, 2, 1, 3)) + tmp54 += ints.tmp409 + tmp54 += ints.tmp413 + tmp54 += ints.tmp423 * 2 + tmp54 += ints.tmp441 + tmp54 += ints.tmp455 + tmp54 += ints.tmp472 + tmp54 += ints.tmp151 * -1 + tmp54 += ints.tmp364 * -2 + tmp54 += ints.tmp384 * -1 + tmp54 += ints.tmp405 * -1 + tmp54 += ints.tmp420 * -2 + tmp54 += ints.tmp427 * -1 + tmp54 += ints.tmp457.transpose((0, 2, 1, 3)) * -1 + tmp54 += ints.tmp464 * -1 + tmp54 += v.bbbb.ooov.transpose((0, 2, 1, 3)) * -1 + tmp53 = ints.tmp156.copy() + tmp53 += ints.tmp333.transpose((0, 2, 1, 3)) + tmp53 += ints.tmp353.transpose((0, 2, 1, 3)) + tmp53 += ints.tmp366.transpose((0, 2, 1, 3)) + tmp53 += ints.tmp370.transpose((0, 2, 1, 3)) * 2 + tmp53 += ints.tmp386 + tmp53 += ints.tmp407 + tmp53 += ints.tmp411 + tmp53 += ints.tmp419 + tmp53 += ints.tmp425 * 2 + tmp53 += ints.tmp466 + tmp53 += v.aabb.ovoo.transpose((0, 2, 3, 1)) + tmp53 += ints.tmp345.transpose((0, 2, 1, 3)) * -1 + tmp53 += ints.tmp363 * -1 + tmp53 += ints.tmp369 * -1 + tmp53 += ints.tmp403 * -1 + tmp53 += ints.tmp422 * -1 + tmp53 += ints.tmp429 * -1 + tmp53 += ints.tmp443 * -1 + tmp53 += ints.tmp459 * -1 + tmp53 += ints.tmp460.transpose((0, 2, 1, 3)) * -1 + tmp53 += ints.tmp474 * -1 + tmp66 = tmp0.copy() * 0.5 + tmp66 += tmp44 * 0.5 + del tmp44 + tmp66 += tmp45 + del tmp45 + tmp62 = v.bbbb.ovvv.copy() + tmp62 += v.bbbb.ovvv.transpose((0, 2, 3, 1)) * -1 + tmp63 = tmp30.copy() + tmp63 += tmp31 * 2 + tmp63 += tmp32 * -1 + tmp63 += tmp34 * -2 + tmp19 = tmp17.copy() + del tmp17 + tmp19 += tmp18 * 0.5 + del tmp18 + tmp57 = ints.tmp247.copy() + tmp57 += v.aabb.oovv + tmp57 += ints.tmp525.transpose((0, 1, 3, 2)) * -1 + tmp4 = ints.tmp141.copy() * 0.5 + tmp4 += ints.tmp145 * 0.5 + tmp4 += ints.tmp15.transpose((1, 2, 0, 3)) * 0.5 + tmp4 += ints.tmp162 + tmp4 += ints.tmp187 * 0.5 + tmp4 += ints.tmp222 * 0.5 + tmp4 += ints.tmp263 * 0.5 + tmp4 += ints.tmp33.transpose((1, 2, 0, 3)) * 0.5 + tmp4 += ints.tmp48.transpose((0, 2, 1, 3)) * 0.5 + tmp4 += ints.tmp74.transpose((0, 2, 1, 3)) + tmp4 += ints.tmp78.transpose((0, 2, 1, 3)) * 0.5 + tmp4 += ints.tmp100 * -0.5 + tmp4 += ints.tmp137 * -0.5 + tmp4 += ints.tmp159 * -1 + tmp4 += ints.tmp165 * -0.5 + tmp4 += ints.tmp224.transpose((0, 2, 1, 3)) * -0.5 + tmp4 += ints.tmp245 * -0.5 + tmp4 += ints.tmp46 * -0.5 + tmp4 += ints.tmp71 * -1 + tmp4 += v.aaaa.ooov.transpose((0, 2, 1, 3)) * -0.5 + tmp36 = ints.tmp30.copy() + tmp36 += v.aaaa.oovv + tmp36 += ints.tmp31 * -1 + tmp36 += v.aaaa.ovov.transpose((0, 2, 3, 1)) * -1 + tmp26 = v.aaaa.ovov.transpose((0, 2, 3, 1)).copy() + tmp26 += v.aaaa.ovov.transpose((0, 2, 1, 3)) * -1 + tmp15 = ints.tmp115.copy() + tmp15 += ints.tmp122 * 0.5 + tmp15 += ints.tmp149 + tmp15 += ints.tmp154 * 0.5 + tmp15 += ints.tmp176 + tmp15 += ints.tmp184 * 0.5 + tmp15 += ints.tmp19 * 0.5 + tmp15 += ints.tmp211 * 0.5 + tmp15 += ints.tmp217 * 0.5 + tmp15 += ints.tmp234 * 0.5 + tmp15 += ints.tmp252 * 0.5 + tmp15 += ints.tmp258 * 0.5 + tmp15 += ints.tmp2 * 0.5 + tmp15 += ints.tmp39 * 0.5 + tmp15 += ints.tmp63 + tmp15 += ints.tmp69 * 0.5 + tmp15 += ints.tmp92 + tmp15 += f.aa.ov * -0.5 + tmp15 += ints.tmp118 * -1 + tmp15 += ints.tmp11 * -0.5 + tmp15 += ints.tmp126 * -0.5 + tmp15 += ints.tmp130 * -1 + tmp15 += ints.tmp133 * -0.5 + tmp15 += ints.tmp209 * -0.5 + tmp15 += ints.tmp231 * -0.5 + tmp15 += ints.tmp243 * -0.5 + tmp15 += ints.tmp250 * -0.5 + tmp15 += ints.tmp37 * -0.5 + tmp15 += ints.tmp44 * -0.5 + tmp15 += ints.tmp5 * -0.5 + tmp15 += ints.tmp8 * -1 + tmp15 += ints.tmp98 * -0.5 + tmp35 = r1.bb.copy() * 0.5 + tmp35 += tmp30 * 0.5 + del tmp30 + tmp35 += tmp31 + del tmp31 + tmp35 += tmp32 * -0.5 + del tmp32 + tmp35 += tmp34 * -1 + del tmp34 + tmp50 = f.aa.oo.copy() + tmp50 += ints.tmp1.transpose((1, 0)) + tmp50 += ints.tmp207 + tmp50 += ints.tmp208 + tmp50 += ints.tmp26.transpose((1, 0)) + tmp50 += ints.tmp27.transpose((1, 0)) + tmp50 += ints.tmp52 * 2 + tmp50 += ints.tmp54 + tmp50 += ints.tmp206 * -1 + tmp50 += ints.tmp25 * -1 + tmp41 = v.aaaa.ooov.copy() + tmp41 += v.aaaa.ovoo.transpose((0, 2, 3, 1)) * -1 + tmp14 = ints.tmp46.copy() + tmp14 += v.aaaa.ooov * -1 + tmp6 = ints.tmp307.copy() + tmp6 += ints.tmp313 * 0.5 + tmp6 += ints.tmp31.transpose((0, 1, 3, 2)) * 0.5 + tmp6 += v.aaaa.ovov.transpose((0, 2, 1, 3)) * 0.5 + tmp6 += ints.tmp30.transpose((0, 1, 3, 2)) * -0.5 + tmp6 += ints.tmp310 * -1 + tmp6 += v.aaaa.oovv * -0.5 + tmp3 = ints.tmp102.copy() * 0.5 + tmp3 += ints.tmp143 * 0.5 + tmp3 += ints.tmp147 * 0.5 + tmp3 += ints.tmp161 * 0.5 + tmp3 += ints.tmp167 + tmp3 += ints.tmp17.transpose((1, 0, 2, 3)) * 0.5 + tmp3 += ints.tmp248 * 0.5 + tmp3 += ints.tmp50 * 0.5 + tmp3 += ints.tmp51.transpose((1, 0, 2, 3)) * 0.5 + tmp3 += ints.tmp76.transpose((1, 0, 2, 3)) * 0.5 + tmp3 += ints.tmp80.transpose((1, 0, 2, 3)) + tmp3 += v.aabb.ooov * 0.5 + tmp3 += ints.tmp139 * -0.5 + tmp3 += ints.tmp164 * -0.5 + tmp3 += ints.tmp169 * -0.5 + tmp3 += ints.tmp190 * -0.5 + tmp3 += ints.tmp227 * -0.5 + tmp3 += ints.tmp229.transpose((1, 0, 2, 3)) * -0.5 + tmp3 += ints.tmp266 * -0.5 + tmp3 += ints.tmp35.transpose((1, 0, 2, 3)) * -0.5 + tmp3 += ints.tmp73 * -0.5 + tmp3 += ints.tmp77 * -0.5 + tmp48 = ints.tmp233.transpose((1, 0)).copy() + tmp48 += ints.tmp278 * 2 + tmp48 += ints.tmp280 + tmp48 += f.aa.vv * -1 + tmp48 += ints.tmp230.transpose((1, 0)) * -1 + tmp48 += ints.tmp242.transpose((1, 0)) * -1 + tmp20 = v.aaaa.ovvv.copy() + tmp20 += v.aaaa.ovvv.transpose((0, 2, 3, 1)) * -1 + tmp2 = ints.tmp282.transpose((0, 3, 1, 2)).copy() * 0.5 + tmp2 += ints.tmp286.transpose((0, 2, 1, 3)) + tmp2 += ints.tmp292.transpose((0, 2, 1, 3)) * 0.5 + tmp2 += v.aaaa.ovvv.transpose((0, 2, 1, 3)) * 0.5 + tmp2 += ints.tmp274 * -0.5 + tmp2 += ints.tmp289.transpose((0, 2, 1, 3)) * -1 + tmp2 += ints.tmp303.transpose((0, 3, 1, 2)) * -0.5 + tmp1 = ints.tmp276.copy() + tmp1 += ints.tmp284.transpose((0, 2, 1, 3)) + tmp1 += ints.tmp288 + tmp1 += ints.tmp294 * 2 + tmp1 += ints.tmp305.transpose((0, 2, 1, 3)) + tmp1 += v.aabb.vvov.transpose((2, 0, 1, 3)) + tmp1 += ints.tmp291 * -1 + tmp1 += ints.tmp296.transpose((0, 2, 1, 3)) * -1 + tmp25 = tmp21.copy() + del tmp21 + tmp25 += tmp22 * 0.5 + del tmp22 + tmp25 += tmp23 * -1 + del tmp23 + tmp25 += tmp24 * -0.5 + del tmp24 + r2new.bbbb = einsum(v.bbbb.vvvv, (0, 1, 2, 3), r2.bbbb, (4, 5, 1, 3), (4, 5, 0, 2)) * 2 + r2new.bbbb += tmp130 + r2new.bbbb += tmp130.transpose((0, 1, 3, 2)) * -1 + del tmp130 + r2new.bbbb += tmp147 * -1 + r2new.bbbb += tmp147.transpose((0, 1, 3, 2)) + r2new.bbbb += tmp147.transpose((1, 0, 2, 3)) + r2new.bbbb += tmp147.transpose((1, 0, 3, 2)) * -1 + del tmp147 + r2new.bbbb += tmp149.transpose((0, 1, 3, 2)) + r2new.bbbb += tmp149.transpose((1, 0, 3, 2)) * -1 + del tmp149 + r2new.bbbb += tmp151.transpose((0, 1, 3, 2)) * -2 + r2new.bbbb += tmp151.transpose((1, 0, 3, 2)) * 2 + del tmp151 + r2new.bbbb += tmp153.transpose((1, 0, 2, 3)) * -2 + r2new.bbbb += tmp153.transpose((1, 0, 3, 2)) * 2 + del tmp153 + r2new.bbbb += tmp155.transpose((1, 0, 2, 3)) + r2new.bbbb += tmp155.transpose((1, 0, 3, 2)) * -1 + del tmp155 + r2new.bbbb += tmp163 + r2new.bbbb += tmp163.transpose((0, 1, 3, 2)) * -1 + r2new.bbbb += tmp163.transpose((1, 0, 2, 3)) * -1 + r2new.bbbb += tmp163.transpose((1, 0, 3, 2)) + del tmp163 + r2new.bbbb += tmp165.transpose((1, 0, 2, 3)) * -2 + r2new.bbbb += tmp165.transpose((1, 0, 3, 2)) * 2 + del tmp165 + r2new.bbbb += einsum(tmp166, (0, 1, 2, 3), r2.bbbb, (0, 1, 4, 5), (2, 3, 4, 5)) * 2 + del tmp166 + r2new.bbbb += einsum(v.bbbb.ovov, (0, 1, 2, 3), tmp167, (4, 5, 0, 2), (5, 4, 3, 1)) * 2 + del tmp167 + r2new.bbbb += einsum(r1.bb, (0, 1), tmp70, (2, 3), (2, 0, 3, 1)) + r2new.bbbb += einsum(tmp70, (0, 1), r1.bb, (2, 3), (2, 0, 3, 1)) + r2new.bbbb += einsum(tmp70, (0, 1), r1.bb, (2, 3), (2, 0, 1, 3)) * -1 + r2new.bbbb += einsum(tmp70, (0, 1), r1.bb, (2, 3), (0, 2, 3, 1)) * -1 + r2new.abab = einsum(v.aabb.vvov, (0, 1, 2, 3), r1.aa, (4, 1), (4, 2, 0, 3)) + r2new.abab += einsum(v.aabb.vvov, (0, 1, 2, 3), tmp9, (4, 5, 2, 1), (4, 5, 0, 3)) * -1 + r2new.abab += einsum(tmp7, (0, 1, 2, 3), v.aabb.ovvv, (1, 4, 5, 3), (0, 2, 4, 5)) * -1 + r2new.abab += einsum(r2.abab, (0, 1, 2, 3), v.aabb.vvvv, (4, 2, 5, 3), (0, 1, 4, 5)) + r2new.abab += einsum(v.aabb.ovvv, (0, 1, 2, 3), r1.bb, (4, 3), (0, 4, 1, 2)) + r2new.abab += einsum(tmp112, (0, 1, 2, 3), r2.abab, (4, 0, 5, 3), (4, 1, 5, 2)) + del tmp112 + r2new.abab += einsum(tmp113, (0, 1, 2, 3), r2.abab, (0, 4, 2, 5), (1, 4, 3, 5)) + del tmp113 + r2new.abab += einsum(r2.bbbb, (0, 1, 2, 3), tmp8, (4, 1, 5, 3), (4, 0, 5, 2)) * 2 + r2new.abab += einsum(tmp114, (0, 1, 2, 3), r2.aaaa, (4, 0, 5, 2), (4, 1, 5, 3)) * 4 + del tmp114 + r2new.abab += einsum(tmp115, (0, 1, 2, 3), r2.abab, (0, 4, 5, 2), (1, 4, 5, 3)) * -1 + del tmp115 + r2new.abab += einsum(tmp10, (0, 1, 2, 3), r2.abab, (4, 0, 2, 5), (4, 1, 3, 5)) * -1 + r2new.abab += einsum(tmp116, (0, 1, 2, 3), r2.abab, (0, 2, 4, 5), (1, 3, 4, 5)) + del tmp116 + r2new.abab += einsum(tmp9, (0, 1, 2, 3), tmp117, (1, 2, 4, 5), (0, 4, 3, 5)) * -1 + del tmp117 + r2new.abab += einsum(tmp118, (0, 1, 2, 3), tmp7, (0, 1, 4, 5), (2, 4, 3, 5)) + del tmp118 + r2new.abab += einsum(tmp119, (0, 1, 2, 3), v.aabb.ovov, (1, 4, 3, 5), (0, 2, 4, 5)) + del tmp119 + r2new.abab += einsum(tmp33, (0, 1, 2, 3), tmp12, (4, 0, 2, 5), (4, 1, 5, 3)) * 2 + r2new.abab += einsum(tmp120, (0, 1, 2, 3), tmp7, (4, 0, 1, 5), (4, 2, 3, 5)) + del tmp120 + r2new.abab += einsum(tmp9, (0, 1, 2, 3), tmp121, (0, 4, 2, 5), (4, 1, 3, 5)) + del tmp121 + r2new.abab += einsum(tmp5, (0, 1, 2, 3), tmp58, (0, 2, 4, 5), (1, 4, 3, 5)) * 2 + r2new.abab += einsum(tmp122, (0, 1), r2.abab, (2, 3, 0, 4), (2, 3, 1, 4)) * -1 + del tmp122 + r2new.abab += einsum(r2.abab, (0, 1, 2, 3), tmp123, (3, 4), (0, 1, 2, 4)) * -1 + del tmp123 + r2new.abab += einsum(tmp124, (0, 1), r2.abab, (0, 2, 3, 4), (1, 2, 3, 4)) * -1 + del tmp124 + r2new.abab += einsum(r2.abab, (0, 1, 2, 3), tmp125, (1, 4), (0, 4, 2, 3)) * -1 + del tmp125 + r2new.abab += einsum(tmp84, (0, 1), v.aabb.ovov, (2, 1, 3, 4), (2, 3, 0, 4)) * -1 + del tmp84 + r2new.abab += einsum(v.aabb.ovov, (0, 1, 2, 3), tmp29, (4, 3), (0, 2, 1, 4)) * -1 + r2new.abab += einsum(tmp70, (0, 1), tmp9, (2, 3, 0, 4), (2, 3, 4, 1)) * -1 + r2new.abab += einsum(tmp7, (0, 1, 2, 3), tmp49, (1, 4), (0, 2, 4, 3)) * -1 + r2new.abab += einsum(v.aabb.ovov, (0, 1, 2, 3), tmp126, (4, 0), (4, 2, 1, 3)) * -1 + del tmp126 + r2new.abab += einsum(tmp46, (0, 1), v.aabb.ovov, (2, 3, 1, 4), (2, 0, 3, 4)) * -1 + r2new.abab += einsum(tmp12, (0, 1, 2, 3), r1.bb, (1, 4), (0, 2, 3, 4)) * -1 + r2new.abab += einsum(tmp58, (0, 1, 2, 3), r1.aa, (0, 4), (1, 2, 4, 3)) * -1 + r2new.abab += einsum(tmp49, (0, 1), r1.bb, (2, 3), (0, 2, 1, 3)) + r2new.abab += einsum(tmp70, (0, 1), r1.aa, (2, 3), (2, 0, 3, 1)) + r2new.aaaa = einsum(v.aaaa.vvvv, (0, 1, 2, 3), r2.aaaa, (4, 5, 3, 1), (4, 5, 0, 2)) * -2 + r2new.aaaa += tmp88 * -1 + r2new.aaaa += tmp88.transpose((0, 1, 3, 2)) + r2new.aaaa += tmp88.transpose((1, 0, 2, 3)) + r2new.aaaa += tmp88.transpose((1, 0, 3, 2)) * -1 + del tmp88 + r2new.aaaa += tmp96 + r2new.aaaa += tmp96.transpose((0, 1, 3, 2)) * -1 + r2new.aaaa += tmp96.transpose((1, 0, 2, 3)) * -1 + r2new.aaaa += tmp96.transpose((1, 0, 3, 2)) + del tmp96 + r2new.aaaa += tmp98.transpose((1, 0, 2, 3)) * -2 + r2new.aaaa += tmp98.transpose((1, 0, 3, 2)) * 2 + del tmp98 + r2new.aaaa += tmp101 * -1 + r2new.aaaa += tmp101.transpose((0, 1, 3, 2)) + del tmp101 + r2new.aaaa += tmp103.transpose((1, 0, 2, 3)) * -2 + r2new.aaaa += tmp103.transpose((1, 0, 3, 2)) * 2 + del tmp103 + r2new.aaaa += tmp105.transpose((1, 0, 2, 3)) + r2new.aaaa += tmp105.transpose((1, 0, 3, 2)) * -1 + del tmp105 + r2new.aaaa += tmp107.transpose((0, 1, 3, 2)) + r2new.aaaa += tmp107.transpose((1, 0, 3, 2)) * -1 + del tmp107 + r2new.aaaa += tmp109.transpose((0, 1, 3, 2)) * -2 + r2new.aaaa += tmp109.transpose((1, 0, 3, 2)) * 2 + del tmp109 + r2new.aaaa += einsum(r2.aaaa, (0, 1, 2, 3), tmp110, (0, 1, 4, 5), (4, 5, 2, 3)) * 2 + del tmp110 + r2new.aaaa += einsum(tmp111, (0, 1, 2, 3), v.aaaa.ovov, (2, 4, 3, 5), (1, 0, 5, 4)) * 2 + del tmp111 + r2new.aaaa += einsum(r1.aa, (0, 1), tmp49, (2, 3), (2, 0, 3, 1)) + r2new.aaaa += einsum(tmp49, (0, 1), r1.aa, (2, 3), (2, 0, 3, 1)) + r2new.aaaa += einsum(tmp49, (0, 1), r1.aa, (2, 3), (2, 0, 1, 3)) * -1 + r2new.aaaa += einsum(tmp49, (0, 1), r1.aa, (2, 3), (0, 2, 3, 1)) * -1 + r1new.bb = einsum(tmp37, (0, 1), ints.tmp50, (0, 1, 2, 3), (2, 3)) * -1 + r1new.bb += einsum(r1.aa, (0, 1), ints.tmp342, (0, 2, 1, 3), (2, 3)) + r1new.bb += einsum(r2.abab, (0, 1, 2, 3), tmp51, (0, 2, 4, 3), (1, 4)) + del tmp51 + r1new.bb += einsum(r2.bbbb, (0, 1, 2, 3), tmp52, (1, 4, 2, 3), (0, 4)) * -4 + del tmp52 + r1new.bb += einsum(tmp53, (0, 1, 2, 3), r2.abab, (0, 1, 3, 4), (2, 4)) * -1 + del tmp53 + r1new.bb += einsum(tmp54, (0, 1, 2, 3), r2.bbbb, (0, 1, 4, 3), (2, 4)) * 2 + del tmp54 + r1new.bb += einsum(tmp33, (0, 1, 2, 3), tmp55, (0, 2, 4, 3), (1, 4)) * -4 + del tmp33, tmp55 + r1new.bb += einsum(tmp56, (0, 1, 2, 3), tmp9, (0, 4, 1, 2), (4, 3)) * -1 + del tmp56 + r1new.bb += einsum(tmp7, (0, 1, 2, 3), tmp57, (0, 1, 4, 3), (2, 4)) * -1 + del tmp57 + r1new.bb += einsum(tmp58, (0, 1, 2, 3), tmp11, (0, 1, 4, 2), (4, 3)) + del tmp58 + r1new.bb += einsum(tmp60, (0, 1, 2, 3), tmp59, (4, 0, 2, 1), (4, 3)) * -2 + del tmp59, tmp60 + r1new.bb += einsum(r2.bbbb, (0, 1, 2, 3), tmp16, (1, 3), (0, 2)) * -2 + r1new.bb += einsum(r2.abab, (0, 1, 2, 3), tmp61, (0, 2), (1, 3)) * -1 + del tmp61 + r1new.bb += einsum(tmp29, (0, 1), tmp62, (2, 1, 0, 3), (2, 3)) * -1 + del tmp62 + r1new.bb += einsum(tmp63, (0, 1), tmp64, (0, 2, 1, 3), (2, 3)) * -1 + del tmp63, tmp64 + r1new.bb += einsum(v.aabb.vvov, (0, 1, 2, 3), tmp19, (1, 0), (2, 3)) * 2 + r1new.bb += einsum(tmp65, (0, 1), v.aabb.ovov, (0, 1, 2, 3), (2, 3)) + del tmp65 + r1new.bb += einsum(tmp66, (0, 1), tmp67, (0, 2, 1, 3), (2, 3)) * -2 + del tmp66, tmp67 + r1new.bb += einsum(r1.bb, (0, 1), tmp68, (0, 2, 3, 1), (2, 3)) * -1 + del tmp68 + r1new.bb += einsum(v.aabb.ooov, (0, 1, 2, 3), tmp40, (1, 0), (2, 3)) * -2 + r1new.bb += einsum(tmp42, (0, 1), ints.tmp50, (0, 1, 2, 3), (2, 3)) * -2 + r1new.bb += einsum(tmp69, (0, 1), r1.bb, (2, 0), (2, 1)) * -1 + del tmp69 + r1new.bb += einsum(tmp46, (0, 1), tmp70, (1, 2), (0, 2)) * -1 + del tmp70 + r1new.bb += einsum(tmp71, (0, 1), r1.bb, (0, 2), (1, 2)) * -1 + del tmp71 + r1new.aa = einsum(tmp0, (0, 1), ints.tmp156, (2, 0, 1, 3), (2, 3)) * -1 + del tmp0 + r1new.aa += einsum(ints.tmp32, (0, 1, 2, 3), r1.bb, (1, 3), (0, 2)) + r1new.aa += einsum(tmp1, (0, 1, 2, 3), r2.abab, (4, 0, 2, 3), (4, 1)) + del tmp1 + r1new.aa += einsum(tmp2, (0, 1, 2, 3), r2.aaaa, (4, 0, 2, 3), (4, 1)) * -4 + del tmp2 + r1new.aa += einsum(tmp3, (0, 1, 2, 3), r2.abab, (0, 2, 4, 3), (1, 4)) * -2 + del tmp3 + r1new.aa += einsum(tmp4, (0, 1, 2, 3), r2.aaaa, (0, 1, 4, 3), (2, 4)) * 4 + del tmp4 + r1new.aa += einsum(tmp6, (0, 1, 2, 3), tmp5, (0, 4, 1, 2), (4, 3)) * -4 + del tmp5, tmp6 + r1new.aa += einsum(tmp7, (0, 1, 2, 3), tmp8, (1, 2, 4, 3), (0, 4)) * -1 + del tmp7, tmp8 + r1new.aa += einsum(tmp10, (0, 1, 2, 3), tmp9, (4, 0, 1, 2), (4, 3)) * -1 + del tmp9, tmp10 + r1new.aa += einsum(tmp12, (0, 1, 2, 3), tmp11, (4, 0, 1, 2), (4, 3)) + del tmp11, tmp12 + r1new.aa += einsum(tmp14, (0, 1, 2, 3), tmp13, (4, 0, 2, 1), (4, 3)) * -2 + del tmp13, tmp14 + r1new.aa += einsum(tmp15, (0, 1), r2.aaaa, (2, 0, 3, 1), (2, 3)) * -4 + del tmp15 + r1new.aa += einsum(r2.abab, (0, 1, 2, 3), tmp16, (1, 3), (0, 2)) * -1 + del tmp16 + r1new.aa += einsum(tmp19, (0, 1), tmp20, (2, 1, 0, 3), (2, 3)) * -2 + del tmp19, tmp20 + r1new.aa += einsum(tmp25, (0, 1), tmp26, (0, 2, 1, 3), (2, 3)) * -2 + del tmp25, tmp26 + r1new.aa += einsum(v.aabb.ovvv, (0, 1, 2, 3), tmp29, (3, 2), (0, 1)) + del tmp29 + r1new.aa += einsum(tmp35, (0, 1), v.aabb.ovov, (2, 3, 0, 1), (2, 3)) * 2 + del tmp35 + r1new.aa += einsum(r1.aa, (0, 1), tmp36, (0, 2, 3, 1), (2, 3)) * -1 + del tmp36 + r1new.aa += einsum(tmp40, (0, 1), tmp41, (1, 0, 2, 3), (2, 3)) * -2 + del tmp41 + r1new.aa += einsum(tmp42, (0, 1), tmp43, (0, 1, 2, 3), (2, 3)) * -2 + del tmp42 + r1new.aa += einsum(tmp46, (0, 1), v.aabb.ovoo, (2, 3, 1, 0), (2, 3)) * -1 + del tmp46 + r1new.aa += einsum(tmp47, (0, 1), ints.tmp156, (2, 0, 1, 3), (2, 3)) * -2 + del tmp47 + r1new.aa += einsum(tmp43, (0, 1, 2, 3), tmp37, (0, 1), (2, 3)) * -1 + del tmp37, tmp43 + r1new.aa += einsum(tmp48, (0, 1), r1.aa, (2, 0), (2, 1)) * -1 + del tmp48 + r1new.aa += einsum(tmp49, (0, 1), tmp40, (2, 0), (2, 1)) * -2 + del tmp49, tmp40 + r1new.aa += einsum(tmp50, (0, 1), r1.aa, (0, 2), (1, 2)) * -1 + del tmp50 + r2new.baba = r2new.abab.transpose(1, 0, 3, 2) + + return {f"r1new": r1new, f"r2new": r2new} + diff --git a/tests/test_RCCSD.py b/tests/test_RCCSD.py index cdc90dc2..973634c8 100644 --- a/tests/test_RCCSD.py +++ b/tests/test_RCCSD.py @@ -232,6 +232,18 @@ def test_eom_ea(self): e2, v2 = self.ccsd_ref.eaccsd(nroots=5) self.assertAlmostEqual(e1[0], e2[0], 5) + def test_eom_ip_left(self): + eom = self.ccsd.ip_eom(nroots=5, left=True) + e1 = eom.kernel() + e2, v2 = self.ccsd_ref.ipccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ea_left(self): + eom = self.ccsd.ea_eom(nroots=5, left=True) + e1 = eom.kernel() + e2, v2 = self.ccsd_ref.eaccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + @pytest.mark.reference class FNORCCSD_PySCF_Tests(RCCSD_PySCF_Tests): @@ -392,6 +404,18 @@ def test_eom_ea(self): e2, v2 = self.ccsd_ref.eaccsd(nroots=5) self.assertAlmostEqual(e1[0], e2[0], 5) + def test_eom_ip_left(self): + eom = self.ccsd.ip_eom(nroots=5, left=True) + e1 = eom.kernel() + e2, v2 = self.ccsd_ref.ipccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ea_left(self): + eom = self.ccsd.ea_eom(nroots=5, left=True) + e1 = eom.kernel() + e2, v2 = self.ccsd_ref.eaccsd(nroots=5, left=True) + self.assertAlmostEqual(e1[0], e2[0], 5) + @pytest.mark.reference class RCCSD_Dump_Tests(RCCSD_PySCF_Tests): diff --git a/tests/test_UCCSD.py b/tests/test_UCCSD.py index be1c2986..59dc62ee 100644 --- a/tests/test_UCCSD.py +++ b/tests/test_UCCSD.py @@ -255,6 +255,21 @@ def test_eom_ee(self): e2, v2 = self.ccsd_ref.eeccsd(nroots=5) self.assertAlmostEqual(e1[0], e2[0], 5) + def test_eom_ip_left(self): + e1 = self.ccsd.ip_eom(nroot=5, left=True).kernel() + e2, v2 = self.ccsd_ref.ipccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ea_left(self): + e1 = self.ccsd.ea_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eaccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ee_left(self): + e1 = self.ccsd.ee_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eeccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + # Disabled until PySCF fix bug # TODO # @pytest.mark.reference @@ -422,6 +437,21 @@ def test_eom_ee(self): e2, v2 = self.ccsd_ref.eeccsd(nroots=5) self.assertAlmostEqual(e1[0], e2[0], 5) + def test_eom_ip_left(self): + e1 = self.ccsd.ip_eom(nroot=5, left=True).kernel() + e2, v2 = self.ccsd_ref.ipccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ea_left(self): + e1 = self.ccsd.ea_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eaccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + + def test_eom_ee_left(self): + e1 = self.ccsd.ee_eom(nroots=5, left=True).kernel() + e2, v2 = self.ccsd_ref.eeccsd(nroots=5) # No left EE-EOM in PySCF + self.assertAlmostEqual(e1[0], e2[0], 5) + @pytest.mark.reference class UCCSD_Dump_Tests(UCCSD_PySCF_Tests): From 1cb4e77e7b3c7dc4e142563da61ab9680e4661b0 Mon Sep 17 00:00:00 2001 From: Oliver Backhouse Date: Tue, 13 Aug 2024 22:55:05 +0100 Subject: [PATCH 8/8] Linting --- ebcc/eom/base.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ebcc/eom/base.py b/ebcc/eom/base.py index 437b82d3..b8207c5c 100644 --- a/ebcc/eom/base.py +++ b/ebcc/eom/base.py @@ -287,7 +287,9 @@ def davidson( # Get the matrix-vector products and the diagonal: ints = self.matvec_intermediates(eris=eris, left=self.options.left) - matvecs = lambda vs: [self.matvec(v, eris=eris, ints=ints, left=self.options.left) for v in vs] + matvecs = lambda vs: [ + self.matvec(v, eris=eris, ints=ints, left=self.options.left) for v in vs + ] diag = self.diag(eris=eris) # Get the guesses: