From 7bbd1b7fc8b679bf86899bbb09aefcd9bdd78a82 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 25 Oct 2024 15:54:54 +0200 Subject: [PATCH 01/88] add to_mpo method to MolecularHamiltonian class --- pyproject.toml | 1 + .../hamiltonians/molecular_hamiltonian.py | 36 ++++++ python/ffsim/tenpy/hamiltonians/__init__.py | 21 ++++ .../hamiltonians/molecular_hamiltonian.py | 111 ++++++++++++++++++ python/ffsim/tenpy/util.py | 46 ++++++++ .../molecular_hamiltonian_test.py | 41 +++++++ 6 files changed, 256 insertions(+) create mode 100644 python/ffsim/tenpy/hamiltonians/__init__.py create mode 100644 python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py create mode 100644 python/ffsim/tenpy/util.py diff --git a/pyproject.toml b/pyproject.toml index 0bd14acd7..3c7f11ec5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,6 +30,7 @@ dependencies = [ "qiskit >= 1.1", "scipy", "typing-extensions", + "physics-tenpy" ] [project.urls] diff --git a/python/ffsim/hamiltonians/molecular_hamiltonian.py b/python/ffsim/hamiltonians/molecular_hamiltonian.py index 0b6d8a721..b076b1941 100644 --- a/python/ffsim/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/hamiltonians/molecular_hamiltonian.py @@ -25,6 +25,7 @@ from ffsim.cistring import gen_linkstr_index from ffsim.operators import FermionOperator, cre_a, cre_b, des_a, des_b from ffsim.states import dim +from ffsim.tenpy.hamiltonians import MolecularHamiltonianMPO @dataclasses.dataclass(frozen=True) @@ -120,6 +121,41 @@ def rotated(self, orbital_rotation: np.ndarray) -> MolecularHamiltonian: constant=self.constant, ) + def to_mpo(self, decimal_places=None): + r"""Return the Hamiltonian as an MPO. + + Args: + decimal_places: The number of decimal places to which to round the input + one-body and two-body tensors. Rounding can sometimes reduce the MPO + bond dimension. + + Return type: + `TeNPy MPO `__ + + Returns: + The Hamiltonian as an MPO. + """ + + if decimal_places: + one_body_tensor = np.round(self.one_body_tensor, decimals=decimal_places) + two_body_tensor = np.round(self.two_body_tensor, decimals=decimal_places) + else: + one_body_tensor = self.one_body_tensor + two_body_tensor = self.two_body_tensor + + model_params = dict( + cons_N="N", + cons_Sz="Sz", + L=1, + norb=self.norb, + one_body_tensor=one_body_tensor, + two_body_tensor=two_body_tensor, + constant=self.constant, + ) + mpo_model = MolecularHamiltonianMPO(model_params) + + return mpo_model.H_MPO + def _linear_operator_(self, norb: int, nelec: tuple[int, int]) -> LinearOperator: """Return a SciPy LinearOperator representing the object.""" n_alpha, n_beta = nelec diff --git a/python/ffsim/tenpy/hamiltonians/__init__.py b/python/ffsim/tenpy/hamiltonians/__init__.py new file mode 100644 index 000000000..27f80f0c6 --- /dev/null +++ b/python/ffsim/tenpy/hamiltonians/__init__.py @@ -0,0 +1,21 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Classes for converting Hamiltonians to TeNPy MPO objects.""" + +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import ( + MolecularChain, + MolecularHamiltonianMPO, +) + +__all__ = [ + "MolecularChain", + "MolecularHamiltonianMPO", +] diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py new file mode 100644 index 000000000..9a3626b11 --- /dev/null +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -0,0 +1,111 @@ +import numpy as np +from tenpy.models.lattice import Lattice +from tenpy.models.model import CouplingMPOModel +from tenpy.networks.site import SpinHalfFermionSite + +# ignore lowercase argument and variable checks to maintain TeNPy naming conventions +# ruff: noqa: N803, N806 + + +class MolecularChain(Lattice): + def __init__(self, L, norb, site_a, **kwargs): + basis = np.array(([norb, 0.0], [0, 1])) + pos = np.array([[i, 0] for i in range(norb)]) + + kwargs.setdefault("order", "default") + kwargs.setdefault("bc", "open") + kwargs.setdefault("bc_MPS", "finite") + kwargs.setdefault("basis", basis) + kwargs.setdefault("positions", pos) + + super().__init__([L, 1], [site_a] * norb, **kwargs) + + +class MolecularHamiltonianMPO(CouplingMPOModel): + def __init__(self, params): + CouplingMPOModel.__init__(self, params) + + def init_sites(self, params): + cons_N = params.get("cons_N", "N") + cons_Sz = params.get("cons_Sz", "Sz") + site = SpinHalfFermionSite(cons_N=cons_N, cons_Sz=cons_Sz) + print(sorted(site.opnames)) + print(site.state_labels) + return site + + def init_lattice(self, params): + L = params.get("L", 1) + norb = params.get("norb", 4) + site = self.init_sites(params) + lat = MolecularChain(L, norb, site, basis=[[norb, 0], [0, 1]]) + return lat + + def init_terms(self, params): + dx0 = np.array([0, 0]) + norb = params.get("norb", 4) + one_body_tensor = params.get("one_body_tensor", np.zeros((norb, norb))) + two_body_tensor = params.get( + "two_body_tensor", np.zeros((norb, norb, norb, norb)) + ) + constant = params.get("constant", 0) + + for p in range(norb): + for q in range(norb): + h1 = one_body_tensor[p, q] + if p == q: + self.add_onsite(h1, p, "Nu") + self.add_onsite(h1, p, "Nd") + self.add_onsite(constant / norb, p, "Id") + else: + self.add_coupling(h1, p, "Cdu", q, "Cu", dx0) + self.add_coupling(h1, p, "Cdd", q, "Cd", dx0) + + for r in range(norb): + for s in range(norb): + h2 = two_body_tensor[p, q, r, s] + if p == q == r == s: + self.add_onsite(h2 / 2, p, "Nu") + self.add_onsite(-h2 / 2, p, "Nu Nu") + self.add_onsite(h2 / 2, p, "Nu") + self.add_onsite(-h2 / 2, p, "Cdu Cd Cdd Cu") + self.add_onsite(h2 / 2, p, "Nd") + self.add_onsite(-h2 / 2, p, "Cdd Cu Cdu Cd") + self.add_onsite(h2 / 2, p, "Nd") + self.add_onsite(-h2 / 2, p, "Nd Nd") + else: + self.add_multi_coupling( + h2 / 2, + [ + ("Cdu", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + h2 / 2, + [ + ("Cdu", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + h2 / 2, + [ + ("Cdd", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cd", dx0, q), + ], + ) + self.add_multi_coupling( + h2 / 2, + [ + ("Cdd", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cd", dx0, q), + ], + ) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py new file mode 100644 index 000000000..db5591e2b --- /dev/null +++ b/python/ffsim/tenpy/util.py @@ -0,0 +1,46 @@ +from tenpy.networks.mps import MPS +from tenpy.networks.site import SpinHalfFermionSite + +import ffsim + + +def product_state_to_mps(norb, nelec, idx): + r"""Return the product state as an MPS. + + Return type: + `TeNPy MPS `__ + + Returns: + The product state as an MPS. + """ + + dim = ffsim.dim(norb, nelec) + + strings = ffsim.addresses_to_strings( + range(dim), norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING + ) + + string = strings[idx] + up_sector = list(string[0:norb].replace("1", "u")) + down_sector = list(string[norb : 2 * norb].replace("1", "d")) + product_state = list(map(lambda x, y: x + y, up_sector, down_sector)) + + for i, site in enumerate(product_state): + if site == "00": + product_state[i] = "empty" + elif site == "u0": + product_state[i] = "up" + elif site == "0d": + product_state[i] = "down" + elif site == "ud": + product_state[i] = "full" + else: + raise ValueError("undefined site") + + # note that the bit positions increase from right to left + product_state = product_state[::-1] + + shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") + psi_mps = MPS.from_product_state([shfs] * norb, product_state) + + return psi_mps diff --git a/tests/python/hamiltonians/molecular_hamiltonian_test.py b/tests/python/hamiltonians/molecular_hamiltonian_test.py index 3b594970a..5ea15e46d 100644 --- a/tests/python/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/hamiltonians/molecular_hamiltonian_test.py @@ -22,6 +22,7 @@ import scipy.sparse.linalg import ffsim +from ffsim.tenpy.util import product_state_to_mps def test_linear_operator(): @@ -166,6 +167,46 @@ def test_rotated(): np.testing.assert_allclose(original_expectation, rotated_expectation) +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_to_mpo(norb: int, nelec: tuple[int, int]): + """Test MPO conversion.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + one_body_tensor = ffsim.random.random_hermitian(norb, seed=rng) + two_body_tensor = ffsim.random.random_two_body_tensor(norb, seed=rng) + constant = rng.standard_normal() + mol_hamiltonian = ffsim.MolecularHamiltonian( + one_body_tensor, two_body_tensor, constant=constant + ) + linop = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo = mol_hamiltonian.to_mpo() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + product_state = np.zeros(dim) + product_state[idx] = 1 + + # convert random product state to MPS + product_state_mps = product_state_to_mps(norb, nelec, idx) + + # test expectation is preserved + original_expectation = np.vdot(product_state, linop @ product_state) + mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(product_state_mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) + + @pytest.mark.filterwarnings("ignore::DeprecationWarning") def test_from_fcidump(tmp_path: pathlib.Path): """Test loading from FCIDUMP.""" From b283f11bc37e7c1dbd46fe460ed8fcc12105bdb0 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 25 Oct 2024 16:11:53 +0200 Subject: [PATCH 02/88] specify class name as MPOModel --- python/ffsim/hamiltonians/molecular_hamiltonian.py | 4 ++-- python/ffsim/tenpy/hamiltonians/__init__.py | 6 +++--- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/python/ffsim/hamiltonians/molecular_hamiltonian.py b/python/ffsim/hamiltonians/molecular_hamiltonian.py index b076b1941..a5e3db8de 100644 --- a/python/ffsim/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/hamiltonians/molecular_hamiltonian.py @@ -25,7 +25,7 @@ from ffsim.cistring import gen_linkstr_index from ffsim.operators import FermionOperator, cre_a, cre_b, des_a, des_b from ffsim.states import dim -from ffsim.tenpy.hamiltonians import MolecularHamiltonianMPO +from ffsim.tenpy.hamiltonians import MolecularHamiltonianMPOModel @dataclasses.dataclass(frozen=True) @@ -152,7 +152,7 @@ def to_mpo(self, decimal_places=None): two_body_tensor=two_body_tensor, constant=self.constant, ) - mpo_model = MolecularHamiltonianMPO(model_params) + mpo_model = MolecularHamiltonianMPOModel(model_params) return mpo_model.H_MPO diff --git a/python/ffsim/tenpy/hamiltonians/__init__.py b/python/ffsim/tenpy/hamiltonians/__init__.py index 27f80f0c6..d0862d8fc 100644 --- a/python/ffsim/tenpy/hamiltonians/__init__.py +++ b/python/ffsim/tenpy/hamiltonians/__init__.py @@ -8,14 +8,14 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Classes for converting Hamiltonians to TeNPy MPO objects.""" +"""Classes for converting Hamiltonians to TeNPy MPOModel objects.""" from ffsim.tenpy.hamiltonians.molecular_hamiltonian import ( MolecularChain, - MolecularHamiltonianMPO, + MolecularHamiltonianMPOModel, ) __all__ = [ "MolecularChain", - "MolecularHamiltonianMPO", + "MolecularHamiltonianMPOModel", ] diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 9a3626b11..bc1c43a3f 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -21,7 +21,7 @@ def __init__(self, L, norb, site_a, **kwargs): super().__init__([L, 1], [site_a] * norb, **kwargs) -class MolecularHamiltonianMPO(CouplingMPOModel): +class MolecularHamiltonianMPOModel(CouplingMPOModel): def __init__(self, params): CouplingMPOModel.__init__(self, params) From 15c5823a3bebd147d47547bc09b09ba7c6567419 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 25 Oct 2024 16:14:55 +0200 Subject: [PATCH 03/88] fix comment --- tests/python/hamiltonians/molecular_hamiltonian_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/python/hamiltonians/molecular_hamiltonian_test.py b/tests/python/hamiltonians/molecular_hamiltonian_test.py index 5ea15e46d..9b84a69e2 100644 --- a/tests/python/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/hamiltonians/molecular_hamiltonian_test.py @@ -198,7 +198,7 @@ def test_to_mpo(norb: int, nelec: tuple[int, int]): product_state = np.zeros(dim) product_state[idx] = 1 - # convert random product state to MPS + # convert product state to MPS product_state_mps = product_state_to_mps(norb, nelec, idx) # test expectation is preserved From 5795e04a5e482ca8c3b09d72e184efd87d5297f0 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 25 Oct 2024 16:20:38 +0200 Subject: [PATCH 04/88] remove print statements --- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index bc1c43a3f..c961f7dba 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -29,8 +29,6 @@ def init_sites(self, params): cons_N = params.get("cons_N", "N") cons_Sz = params.get("cons_Sz", "Sz") site = SpinHalfFermionSite(cons_N=cons_N, cons_Sz=cons_Sz) - print(sorted(site.opnames)) - print(site.state_labels) return site def init_lattice(self, params): From acc984544ee365ac29afe3f44d264b5917167fbd Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 25 Oct 2024 16:28:23 +0200 Subject: [PATCH 05/88] add docstrings for TeNPy classes --- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index c961f7dba..57c7031a0 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -8,6 +8,8 @@ class MolecularChain(Lattice): + """Molecular chain.""" + def __init__(self, L, norb, site_a, **kwargs): basis = np.array(([norb, 0.0], [0, 1])) pos = np.array([[i, 0] for i in range(norb)]) @@ -22,6 +24,8 @@ def __init__(self, L, norb, site_a, **kwargs): class MolecularHamiltonianMPOModel(CouplingMPOModel): + """Molecular Hamiltonian MPOModel.""" + def __init__(self, params): CouplingMPOModel.__init__(self, params) From 38078be8a8e5229e966e85f6ed301b7d55c6633c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 27 Oct 2024 14:51:15 +0100 Subject: [PATCH 06/88] add lucj_circuit_as_mps function --- docs/how-to-guides/index.md | 1 + docs/how-to-guides/lucj_mps.ipynb | 326 ++++++++++++++++++ python/ffsim/tenpy/circuits/gates.py | 197 +++++++++++ python/ffsim/tenpy/circuits/lucj_circuit.py | 118 +++++++ python/ffsim/tenpy/hamiltonians/__init__.py | 6 +- python/ffsim/tenpy/hamiltonians/lattices.py | 21 ++ .../hamiltonians/molecular_hamiltonian.py | 21 +- python/ffsim/tenpy/util.py | 2 +- .../molecular_hamiltonian_test.py | 4 +- 9 files changed, 671 insertions(+), 25 deletions(-) create mode 100644 docs/how-to-guides/lucj_mps.ipynb create mode 100644 python/ffsim/tenpy/circuits/gates.py create mode 100644 python/ffsim/tenpy/circuits/lucj_circuit.py create mode 100644 python/ffsim/tenpy/hamiltonians/lattices.py diff --git a/docs/how-to-guides/index.md b/docs/how-to-guides/index.md index 57c22a882..155d4c147 100644 --- a/docs/how-to-guides/index.md +++ b/docs/how-to-guides/index.md @@ -4,6 +4,7 @@ :maxdepth: 1 lucj +lucj_mps entanglement-forging fermion-operator qiskit-circuits diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb new file mode 100644 index 000000000..37793aab4 --- /dev/null +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bd5ac3333ca6e15b", + "metadata": {}, + "source": [ + "# How to simulate the LUCJ ansatz using matrix product states" + ] + }, + { + "cell_type": "markdown", + "id": "bdf3ae858d82fccb", + "metadata": {}, + "source": [ + "Following from the previous guide, we show how to use ffsim to simulate the [LUCJ ansatz](../explanations/lucj.ipynb) using matrix product states. In this way, we can calculate an approximation to the LUCJ energy, which is itself an approximation to the ground state energy, for an ethene molecule. This is particularly useful in complicated cases, such as for large molecules, where even the LUCJ energy cannot be computed exactly. \n", + "\n", + "As before, let's start by building the molecule." + ] + }, + { + "cell_type": "code", + "id": "7561238774dbb8b", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:20.643194Z", + "start_time": "2024-10-27T13:48:19.868560Z" + } + }, + "source": [ + "import pyscf\n", + "import pyscf.mcscf\n", + "\n", + "import ffsim\n", + "\n", + "# Build an ethene molecule\n", + "bond_distance = 1.339\n", + "a = 0.5 * bond_distance\n", + "b = a + 0.5626\n", + "c = 0.9289\n", + "mol = pyscf.gto.Mole()\n", + "mol.build(\n", + " atom=[\n", + " [\"C\", (0, 0, a)],\n", + " [\"C\", (0, 0, -a)],\n", + " [\"H\", (0, c, b)],\n", + " [\"H\", (0, -c, b)],\n", + " [\"H\", (0, c, -b)],\n", + " [\"H\", (0, -c, -b)],\n", + " ],\n", + " basis=\"sto-6g\",\n", + " symmetry=\"d2h\",\n", + ")\n", + "\n", + "# Define active space\n", + "active_space = range(mol.nelectron // 2 - 2, mol.nelectron // 2 + 2)\n", + "\n", + "# Get molecular data and molecular Hamiltonian (one- and two-body tensors)\n", + "scf = pyscf.scf.RHF(mol).run()\n", + "mol_data = ffsim.MolecularData.from_scf(scf, active_space=active_space)\n", + "norb = mol_data.norb\n", + "nelec = mol_data.nelec\n", + "mol_hamiltonian = mol_data.hamiltonian\n", + "\n", + "# Compute FCI energy\n", + "mol_data.run_fci()\n", + "\n", + "print(f\"norb = {norb}\")\n", + "print(f\"nelec = {nelec}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converged SCF energy = -77.8266321248745\n", + "Parsing /tmp/tmp961hod15\n", + "converged SCF energy = -77.8266321248745\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/bart/PycharmProjects/ffsim/.ffsim/lib/python3.10/site-packages/pyscf/gto/mole.py:1286: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", + " warnings.warn(msg)\n" + ] + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "c0bd6bd083d51e00", + "metadata": {}, + "source": [ + "Since our molecule has a closed-shell Hartree-Fock state, we'll use the spin-balanced variant of the UCJ ansatz, [UCJOpSpinBalanced](../api/ffsim.rst#ffsim.UCJOpSpinBalanced). We'll initialize the ansatz from t2 amplitudes obtained from a CCSD calculation and we'll restrict same-spin interactions to a line topology, and opposite-spin interactions to those within the same spatial orbital, which allows the ansatz to be simulated directly on a square lattice.\n", + "\n", + "The following code cell initializes the LUCJ ansatz operator." + ] + }, + { + "cell_type": "code", + "id": "435b6d06934db617", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:20.978075Z", + "start_time": "2024-10-27T13:48:20.654739Z" + } + }, + "source": [ + "from pyscf import cc\n", + "\n", + "# Get CCSD t2 amplitudes for initializing the ansatz\n", + "ccsd = cc.CCSD(\n", + " scf,\n", + " frozen=[i for i in range(mol.nao_nr()) if i not in active_space],\n", + ").run()\n", + "\n", + "# Construct LUCJ operator\n", + "n_reps = 1\n", + "pairs_aa = [(p, p + 1) for p in range(norb - 1)]\n", + "pairs_ab = [(p, p) for p in range(norb)]\n", + "interaction_pairs = (pairs_aa, pairs_ab)\n", + "\n", + "lucj_operator = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n", + " ccsd.t2, n_reps=n_reps, interaction_pairs=interaction_pairs\n", + ")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "E(CCSD) = -77.87421536374038 E_corr = -0.04758323886585098\n" + ] + } + ], + "execution_count": 8 + }, + { + "cell_type": "markdown", + "id": "e2a567f699df4868", + "metadata": {}, + "source": [ + "## Convert the Hamiltonian to a matrix product operator (MPO)" + ] + }, + { + "cell_type": "markdown", + "id": "2824dff2829fccbf", + "metadata": {}, + "source": [ + "Currently, our Hamiltonian is an instance of the `MolecularHamiltonian` class. Using the `to_mpo` class method, we can convert this to a TeNPy MPO, which respects the fermionic symmetries. We can now use this MPO object as in the TeNPy documentation. For example, the attribute `chi` tells us the MPO bond dimension, which is an important indicator for how complicated the Hamiltonian is an MPO representation. Optionally, we can pass the `decimal_places` argument to the `to_mpo` class method, which rounds the precision of the one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." + ] + }, + { + "cell_type": "code", + "id": "7faac9a01ef5ba0a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:21.712055Z", + "start_time": "2024-10-27T13:48:20.997730Z" + } + }, + "source": [ + "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", + "hamiltonian_mpo = mol_hamiltonian.to_mpo()\n", + "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", + "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "original Hamiltonian type = \n", + "converted Hamiltonian type = \n", + "maximum MPO bond dimension = 54\n" + ] + } + ], + "execution_count": 9 + }, + { + "cell_type": "markdown", + "id": "ad645d3446decfa8", + "metadata": {}, + "source": [ + "## Construct the LUCJ circuit as a matrix product state (MPS)" + ] + }, + { + "cell_type": "markdown", + "id": "5f989277d7cbbca8", + "metadata": {}, + "source": [ + "Currently, our wavefunction ansatz operator is an instance of the `UCJOpSpinBalanced` class. In a future guide, we will show how to write this as a Qiskit circuit, which is based on qubit gates. In this guide, we will use this ansatz operator to construct our wavefunction as a TeNPy MPS, which respects the fermionic symmetries. Behind the scenes, this executes the ansatz as a fermionic circuit using the TEBD algorithm. We can pass the `trunc_params` dictionary and `norm_tol` to the `lucj_circuit_as_mps` function to control the accuracy of our MPS approximation. These parameters are detailed in the TeNPy documentation. The most important keys in `trunc_params` are `chi_max`, which sets the maximum bond dimension, and `svd_min`, which sets the minimum Schmidt value cutoff. Additionally, the `norm_tol` parameter sets the maximum norm error above which the wavefunction is recanonicalized. " + ] + }, + { + "cell_type": "code", + "id": "e9d8e1b09ee778c2", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:22.585845Z", + "start_time": "2024-10-27T13:48:21.730120Z" + } + }, + "source": [ + "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", + "\n", + "trunc_params = {\"chi_max\": 16, \"svd_min\": 1e-6}\n", + "psi_mps = lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5)\n", + "print(\"wavefunction type = \", type(psi_mps))" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wavefunction type = \n" + ] + } + ], + "execution_count": 10 + }, + { + "cell_type": "markdown", + "id": "6c97e4db54214ecd", + "metadata": {}, + "source": [ + "## Compare the energies" + ] + }, + { + "cell_type": "markdown", + "id": "9c8924340fc05c75", + "metadata": {}, + "source": [ + "Now that we have converted our `MolecularHamilonian` to an MPO, and our LUCJ ansatz to an MPS, we can contract the tensors to compute the energy. In order of increasing accuracy, we can compare the LUCJ (MPS) energy, the LUCJ energy, and the FCI energy." + ] + }, + { + "cell_type": "code", + "id": "a6a7d85060f3d8a2", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:22.711608Z", + "start_time": "2024-10-27T13:48:22.629846Z" + } + }, + "source": [ + "import numpy as np\n", + "from qiskit.circuit import QuantumCircuit, QuantumRegister\n", + "\n", + "# Compute the LUCJ (MPS) energy\n", + "lucj_mps_energy = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", + "print(\"LUCJ (MPS) energy = \", lucj_mps_energy)\n", + "\n", + "# Compute the LUCJ energy\n", + "qubits = QuantumRegister(2 * norb)\n", + "circuit = QuantumCircuit(qubits)\n", + "circuit.append(ffsim.qiskit.PrepareHartreeFockJW(norb, nelec), qubits)\n", + "circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_operator), qubits)\n", + "lucj_state = ffsim.qiskit.final_state_vector(circuit).vec\n", + "hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb=norb, nelec=nelec)\n", + "lucj_energy = np.real(np.vdot(lucj_state, hamiltonian @ lucj_state))\n", + "print(\"LUCJ energy = \", lucj_energy)\n", + "\n", + "# Print the FCI energy\n", + "fci_energy = mol_data.fci_energy\n", + "print(\"FCI energy = \", fci_energy)" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LUCJ (MPS) energy = -77.84651018653355\n", + "LUCJ energy = -77.82366375743965\n", + "FCI energy = -77.87421656438633\n" + ] + } + ], + "execution_count": 11 + }, + { + "cell_type": "code", + "id": "60437fea79a57ec0", + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-27T13:48:22.764638Z", + "start_time": "2024-10-27T13:48:22.762324Z" + } + }, + "source": [], + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py new file mode 100644 index 000000000..e2ed8042f --- /dev/null +++ b/python/ffsim/tenpy/circuits/gates.py @@ -0,0 +1,197 @@ +import numpy as np +import scipy as sp +import tenpy.linalg.np_conserved as npc # TeNPy wrapper around numpy +from tenpy.linalg.charges import LegPipe +from tenpy.networks.site import SpinHalfFermionSite + +# ignore lowercase function, argument, and variable checks to maintain TeNPy naming +# conventions +# ruff: noqa: N802, N803, N806 + +# define sites +shfs_nosym = SpinHalfFermionSite(cons_N=None, cons_Sz=None) +shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") +shfsc = LegPipe([shfs.leg, shfs.leg]) + + +def sym_cons_basis(gate): + # convert to (N, Sz)-symmetry-conserved basis + if np.shape(gate) == (4, 4): # 1-site gate + swap_list = [1, 3, 0, 2] + elif np.shape(gate) == (16, 16): # 2-site gate + swap_list = [5, 11, 2, 7, 12, 15, 9, 14, 1, 6, 0, 3, 8, 13, 4, 10] + else: + raise ValueError( + "only 1-site and 2-site gates implemented for symmetry basis conversion" + ) + + P = np.zeros(np.shape(gate)) + for i, s in enumerate(swap_list): + P[i, s] = 1 + + gate_sym = P.T @ gate @ P + + return gate_sym + + +def XXPlusYY(spin, theta, beta, conj=False): + # define conjugate operator + if conj: + beta = -beta + + # define operators + Id = shfs_nosym.get_op("Id").to_ndarray() + JW = shfs_nosym.get_op("JW").to_ndarray() + + if spin == "up": + # alpha sector / up spins + Cdu = shfs_nosym.get_op("Cdu").to_ndarray() + Cu = shfs_nosym.get_op("Cu").to_ndarray() + JWu = shfs_nosym.get_op("JWu").to_ndarray() + Nu = shfs_nosym.get_op("Nu").to_ndarray() + # + Xu1 = (Cdu + Cu) @ JW + Xu2 = (Cdu + Cu) @ JWu + Yu1 = -1j * (Cdu - Cu) @ JW + Yu2 = -1j * (Cdu - Cu) @ JWu + Zu = 2 * Nu - Id + RZu0 = np.kron(sp.linalg.expm(-1j * (beta / 2) * Zu), Id) + # + XYgate = ( + np.conj(RZu0) + @ sp.linalg.expm( + -1j * (theta / 4) * (np.kron(Xu1, Xu2) + np.kron(Yu1, Yu2)) + ) + @ RZu0 + ) + elif spin == "down": + # beta sector / down spins + Cdd = shfs_nosym.get_op("Cdd").to_ndarray() + Cd = shfs_nosym.get_op("Cd").to_ndarray() + JWd = shfs_nosym.get_op("JWd").to_ndarray() + Nd = shfs_nosym.get_op("Nd").to_ndarray() + # + Xd1 = (Cdd + Cd) @ JW + Xd2 = (Cdd + Cd) @ JWd + Yd1 = -1j * (Cdd - Cd) @ JW + Yd2 = -1j * (Cdd - Cd) @ JWd + Zd = 2 * Nd - Id + RZd0 = np.kron(sp.linalg.expm(-1j * (beta / 2) * Zd), Id) + # + XYgate = ( + np.conj(RZd0) + @ sp.linalg.expm( + -1j * (theta / 4) * (np.kron(Xd1, Xd2) + np.kron(Yd1, Yd2)) + ) + @ RZd0 + ) + else: + raise ValueError("undefined spin") + + # convert to (N, Sz)-symmetry-conserved basis + XYgate_sym = sym_cons_basis(XYgate) + + return XYgate_sym + + +def Phase(spin, theta): + # define operators + Id = shfs_nosym.get_op("Id").to_ndarray() + + if spin == "up": + # alpha sector / up spins + Nu = shfs_nosym.get_op("Nu").to_ndarray() + Zu = 2 * Nu - Id + RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) + Pgate = np.exp(1j * (theta / 2)) * RZu + elif spin == "down": + # beta sector / down spins + Nd = shfs_nosym.get_op("Nd").to_ndarray() + Zd = 2 * Nd - Id + RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) + Pgate = np.exp(1j * (theta / 2)) * RZd + else: + raise ValueError("undefined spin") + + # convert to (N, Sz)-symmetry-conserved basis + Pgate_sym = sym_cons_basis(Pgate) + + return Pgate_sym + + +def CPhase_onsite(theta): + CPgate = np.eye(4, dtype=complex) + CPgate[3, 3] = np.exp(-1j * theta) # minus sign + + # convert to (N, Sz)-symmetry-conserved basis + CPgate_sym = sym_cons_basis(CPgate) + + return CPgate_sym + + +def CPhase(spin, theta): + # define operators + Id = shfs_nosym.get_op("Id").to_ndarray() + + state_0 = np.array([1, 0, 0, 0]) + state_1 = np.array([0, 1, 0, 0]) + state_2 = np.array([0, 0, 1, 0]) + state_3 = np.array([0, 0, 0, 1]) + + outer_0 = np.outer(state_0, state_0) + outer_1 = np.outer(state_1, state_1) + outer_2 = np.outer(state_2, state_2) + outer_3 = np.outer(state_3, state_3) + + if spin == "up": + # alpha sector / up spins + Nu = shfs_nosym.get_op("Nu").to_ndarray() + Zu = 2 * Nu - Id + RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) + Pup = np.exp(-1j * (theta / 2)) * RZu # minus sign + CPgate = ( + np.kron(outer_0, Id) + + np.kron(outer_1, Pup) + + np.kron(outer_2, Id) + + np.kron(outer_3, Pup) + ) + elif spin == "down": + # beta sector / down spins + Nd = shfs_nosym.get_op("Nd").to_ndarray() + Zd = 2 * Nd - Id + RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) + Pdw = np.exp(-1j * (theta / 2)) * RZd # minus sign + CPgate = ( + np.kron(outer_0, Id) + + np.kron(outer_1, Id) + + np.kron(outer_2, Pdw) + + np.kron(outer_3, Pdw) + ) + else: + raise ValueError("undefined spin") + + # convert to (N, Sz)-symmetry-conserved basis + CPgate_sym = sym_cons_basis(CPgate) + + return CPgate_sym + + +def gate1(U1, site, psi): + # on-site + U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) + psi.apply_local_op(site, U1_npc) + + +def gate2(U2, site, psi, eng, chi_list, norm_tol): + # bond between (site-1, site) + U2_npc = npc.Array.from_ndarray( + U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] + ) + U2_npc_split = U2_npc.split_legs() + eng.update_bond(site, U2_npc_split) + chi_list.append(psi.chi) + + # recanonicalize psi if below error threshold + if np.linalg.norm(psi.norm_test()) > norm_tol: + # print("norm error = ", np.linalg.norm(psi.norm_test())) + psi.canonical_form_finite() diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py new file mode 100644 index 000000000..43f87af4f --- /dev/null +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -0,0 +1,118 @@ +import numpy as np +from qiskit.circuit import QuantumCircuit, QuantumRegister +from tenpy.algorithms.tebd import TEBDEngine + +import ffsim +from ffsim.tenpy.circuits.gates import ( + CPhase, + CPhase_onsite, + Phase, + XXPlusYY, + gate1, + gate2, +) +from ffsim.tenpy.util import product_state_as_mps + +# from tenpy.models.hubbard import FermiHubbardChain + + +def lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5): + r"""Return the LUCJ circuit as an MPS. + + Args: + norb: The number of spatial orbitals. + nelec: Either a single integer representing the number of fermions for a + spinless system, or a pair of integers storing the numbers of spin alpha + and spin beta fermions. + lucj_operator: The LUCJ operator. + trunc_params: The truncation parameters for the TEBD gates, as defined in the + TeNPy documentation. + norm_tol: The norm error above which we recanonicalize the wavefunction, as + defined in the TeNPy documentation. + + Return type: + `TeNPy MPS `__ + + Returns: + The LUCJ circuit as an MPS. + """ + + # initialize chi_list + chi_list = [] + + # prepare initial Hartree-Fock state + psi = product_state_as_mps(norb, nelec, 0) + + # construct the qiskit circuit + qubits = QuantumRegister(2 * norb) + circuit = QuantumCircuit(qubits) + circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_operator), qubits) + + # define the TEBD engine + # dummy_model = FermiHubbardChain( + # {'cons_N': 'N', 'cons_Sz': 'Sz', 'L': 2 * norb, 't': 1, 'U': 2, 'mu': 0, + # 'V': 0, 'bc_x': 'open', 'bc_MPS': 'finite'}) + eng = TEBDEngine(psi, None, {"trunc_params": trunc_params}) + + # execute the tenpy circuit + for ins in circuit.decompose(reps=2): + if ins.operation.name == "p": + qubit = ins.qubits[0] + idx = qubit._index + spin_flag = "up" if idx < norb else "down" + lmbda = ins.operation.params[0] + gate1(Phase(spin_flag, lmbda), idx % norb, psi) + elif ins.operation.name == "xx_plus_yy": + qubit0 = ins.qubits[0] + qubit1 = ins.qubits[1] + idx0, idx1 = qubit0._index, qubit1._index + if idx0 < norb and idx1 < norb: + spin_flag = "up" + elif idx0 >= norb and idx1 >= norb: + spin_flag = "down" + else: + raise ValueError("XXPlusYY gate not allowed across spin sectors") + theta_val = ins.operation.params[0] + beta_val = ins.operation.params[1] + # directionality important when beta!=0 + conj_flag = True if idx0 > idx1 else False + gate2( + XXPlusYY(spin_flag, theta_val, beta_val, conj_flag), + max(idx0 % norb, idx1 % norb), + psi, + eng, + chi_list, + norm_tol, + ) + elif ins.operation.name == "cp": + qubit0 = ins.qubits[0] + qubit1 = ins.qubits[1] + idx0, idx1 = qubit0._index, qubit1._index + lmbda = ins.operation.params[0] + # onsite (different spins) + if np.abs(idx0 - idx1) == norb: + gate1(CPhase_onsite(lmbda), min(idx0, idx1), psi) + # NN (up spins) + elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: + gate2( + CPhase("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol + ) + # NN (down spins) + elif np.abs(idx0 - idx1) == 1 and idx0 >= norb and idx1 >= norb: + gate2( + CPhase("down", lmbda), + max(idx0 % norb, idx1 % norb), + psi, + eng, + chi_list, + norm_tol, + ) + else: + raise ValueError( + "CPhase only implemented onsite (different spins) " + "and NN (same spins)" + ) + else: + raise ValueError(f"gate {ins.operation.name} not implemented.") + + return psi diff --git a/python/ffsim/tenpy/hamiltonians/__init__.py b/python/ffsim/tenpy/hamiltonians/__init__.py index d0862d8fc..68bab34ba 100644 --- a/python/ffsim/tenpy/hamiltonians/__init__.py +++ b/python/ffsim/tenpy/hamiltonians/__init__.py @@ -10,10 +10,8 @@ """Classes for converting Hamiltonians to TeNPy MPOModel objects.""" -from ffsim.tenpy.hamiltonians.molecular_hamiltonian import ( - MolecularChain, - MolecularHamiltonianMPOModel, -) +from ffsim.tenpy.hamiltonians.lattices import MolecularChain +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel __all__ = [ "MolecularChain", diff --git a/python/ffsim/tenpy/hamiltonians/lattices.py b/python/ffsim/tenpy/hamiltonians/lattices.py new file mode 100644 index 000000000..a60d79cfa --- /dev/null +++ b/python/ffsim/tenpy/hamiltonians/lattices.py @@ -0,0 +1,21 @@ +import numpy as np +from tenpy.models.lattice import Lattice + +# ignore lowercase argument checks to maintain TeNPy naming conventions +# ruff: noqa: N803 + + +class MolecularChain(Lattice): + """Molecular chain.""" + + def __init__(self, L, norb, site_a, **kwargs): + basis = np.array(([norb, 0.0], [0, 1])) + pos = np.array([[i, 0] for i in range(norb)]) + + kwargs.setdefault("order", "default") + kwargs.setdefault("bc", "open") + kwargs.setdefault("bc_MPS", "finite") + kwargs.setdefault("basis", basis) + kwargs.setdefault("positions", pos) + + super().__init__([L, 1], [site_a] * norb, **kwargs) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 57c7031a0..c380d3e4b 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -1,26 +1,11 @@ import numpy as np -from tenpy.models.lattice import Lattice from tenpy.models.model import CouplingMPOModel from tenpy.networks.site import SpinHalfFermionSite -# ignore lowercase argument and variable checks to maintain TeNPy naming conventions -# ruff: noqa: N803, N806 +from ffsim.tenpy.hamiltonians.lattices import MolecularChain - -class MolecularChain(Lattice): - """Molecular chain.""" - - def __init__(self, L, norb, site_a, **kwargs): - basis = np.array(([norb, 0.0], [0, 1])) - pos = np.array([[i, 0] for i in range(norb)]) - - kwargs.setdefault("order", "default") - kwargs.setdefault("bc", "open") - kwargs.setdefault("bc_MPS", "finite") - kwargs.setdefault("basis", basis) - kwargs.setdefault("positions", pos) - - super().__init__([L, 1], [site_a] * norb, **kwargs) +# ignore lowercase variable checks to maintain TeNPy naming conventions +# ruff: noqa: N806 class MolecularHamiltonianMPOModel(CouplingMPOModel): diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index db5591e2b..e400af607 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -4,7 +4,7 @@ import ffsim -def product_state_to_mps(norb, nelec, idx): +def product_state_as_mps(norb, nelec, idx): r"""Return the product state as an MPS. Return type: diff --git a/tests/python/hamiltonians/molecular_hamiltonian_test.py b/tests/python/hamiltonians/molecular_hamiltonian_test.py index 9b84a69e2..a04cf58a5 100644 --- a/tests/python/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/hamiltonians/molecular_hamiltonian_test.py @@ -22,7 +22,7 @@ import scipy.sparse.linalg import ffsim -from ffsim.tenpy.util import product_state_to_mps +from ffsim.tenpy.util import product_state_as_mps def test_linear_operator(): @@ -199,7 +199,7 @@ def test_to_mpo(norb: int, nelec: tuple[int, int]): product_state[idx] = 1 # convert product state to MPS - product_state_mps = product_state_to_mps(norb, nelec, idx) + product_state_mps = product_state_as_mps(norb, nelec, idx) # test expectation is preserved original_expectation = np.vdot(product_state, linop @ product_state) From 7b8113b37732815998a9c453ca8c84f88c9ad022 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 10:32:32 +0100 Subject: [PATCH 07/88] update how-to notebook --- docs/how-to-guides/lucj_mps.ipynb | 306 +++++++++++++++----- python/ffsim/tenpy/circuits/lucj_circuit.py | 11 +- 2 files changed, 237 insertions(+), 80 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 37793aab4..a9cb2b426 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -20,6 +20,7 @@ }, { "cell_type": "code", + "execution_count": 1, "id": "7561238774dbb8b", "metadata": { "ExecuteTime": { @@ -27,6 +28,31 @@ "start_time": "2024-10-27T13:48:19.868560Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converged SCF energy = -77.8266321248744\n", + "Parsing /tmp/tmpmp33ub72\n", + "converged SCF energy = -77.8266321248744\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Overwritten attributes get_hcore get_ovlp of \n", + "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", + " warnings.warn(msg)\n", + "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", + " warnings.warn(msg)\n" + ] + } + ], "source": [ "import pyscf\n", "import pyscf.mcscf\n", @@ -67,30 +93,7 @@ "\n", "print(f\"norb = {norb}\")\n", "print(f\"nelec = {nelec}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp961hod15\n", - "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", - "norb = 4\n", - "nelec = (2, 2)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/bart/PycharmProjects/ffsim/.ffsim/lib/python3.10/site-packages/pyscf/gto/mole.py:1286: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", - " warnings.warn(msg)\n" - ] - } - ], - "execution_count": 7 + ] }, { "cell_type": "markdown", @@ -104,6 +107,7 @@ }, { "cell_type": "code", + "execution_count": 2, "id": "435b6d06934db617", "metadata": { "ExecuteTime": { @@ -111,6 +115,22 @@ "start_time": "2024-10-27T13:48:20.654739Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "E(CCSD) = -77.87421536374028 E_corr = -0.04758323886583927\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " does not have attributes converged\n" + ] + } + ], "source": [ "from pyscf import cc\n", "\n", @@ -129,17 +149,7 @@ "lucj_operator = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n", " ccsd.t2, n_reps=n_reps, interaction_pairs=interaction_pairs\n", ")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "E(CCSD) = -77.87421536374038 E_corr = -0.04758323886585098\n" - ] - } - ], - "execution_count": 8 + ] }, { "cell_type": "markdown", @@ -154,11 +164,12 @@ "id": "2824dff2829fccbf", "metadata": {}, "source": [ - "Currently, our Hamiltonian is an instance of the `MolecularHamiltonian` class. Using the `to_mpo` class method, we can convert this to a TeNPy MPO, which respects the fermionic symmetries. We can now use this MPO object as in the TeNPy documentation. For example, the attribute `chi` tells us the MPO bond dimension, which is an important indicator for how complicated the Hamiltonian is an MPO representation. Optionally, we can pass the `decimal_places` argument to the `to_mpo` class method, which rounds the precision of the one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." + "Currently, our Hamiltonian is an instance of the `MolecularHamiltonian` class. Using the `to_mpo` class method, we can convert this to a TeNPy MPO, which respects the fermionic symmetries. We can now use this MPO object as outlined in the [TeNPy MPO documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.networks.mpo.MPO.html#tenpy.networks.mpo.MPO). For example, the class attribute `chi` tells us the MPO bond dimension, which is an important indicator of how complicated the Hamiltonian is in an MPO representation." ] }, { "cell_type": "code", + "execution_count": 3, "id": "7faac9a01ef5ba0a", "metadata": { "ExecuteTime": { @@ -166,12 +177,6 @@ "start_time": "2024-10-27T13:48:20.997730Z" } }, - "source": [ - "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", - "hamiltonian_mpo = mol_hamiltonian.to_mpo()\n", - "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", - "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" - ], "outputs": [ { "name": "stdout", @@ -179,11 +184,62 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 54\n" + "maximum MPO bond dimension = 58\n" ] } ], - "execution_count": 9 + "source": [ + "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", + "hamiltonian_mpo = mol_hamiltonian.to_mpo()\n", + "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", + "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" + ] + }, + { + "cell_type": "markdown", + "id": "3fd02a8e-5675-4010-b24b-41259303e16c", + "metadata": {}, + "source": [ + "Optionally, we can pass the `decimal_places` argument to the `to_mpo` class method, which rounds the precision of the input one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "501c1a64-576d-48c9-9018-5e2053adddd5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from matplotlib.ticker import MaxNLocator\n", + "\n", + "dp_list = np.arange(1, 16, dtype=int)\n", + "chi_list = []\n", + "for dp in dp_list:\n", + " hamiltonian_mpo = mol_hamiltonian.to_mpo(decimal_places=dp)\n", + " chi_list.append(max(hamiltonian_mpo.chi))\n", + "\n", + "fig = plt.figure()\n", + "ax = plt.subplot(111)\n", + "ax.plot(dp_list, chi_list, \".-\")\n", + "ax.set_xlabel(\"precision of one-body and two-body tensors / decimal places\")\n", + "ax.set_ylabel(\"maximum MPO bond dimension\")\n", + "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n", + "ax.grid(visible=True)\n", + "plt.show()" + ] }, { "cell_type": "markdown", @@ -198,11 +254,16 @@ "id": "5f989277d7cbbca8", "metadata": {}, "source": [ - "Currently, our wavefunction ansatz operator is an instance of the `UCJOpSpinBalanced` class. In a future guide, we will show how to write this as a Qiskit circuit, which is based on qubit gates. In this guide, we will use this ansatz operator to construct our wavefunction as a TeNPy MPS, which respects the fermionic symmetries. Behind the scenes, this executes the ansatz as a fermionic circuit using the TEBD algorithm. We can pass the `trunc_params` dictionary and `norm_tol` to the `lucj_circuit_as_mps` function to control the accuracy of our MPS approximation. These parameters are detailed in the TeNPy documentation. The most important keys in `trunc_params` are `chi_max`, which sets the maximum bond dimension, and `svd_min`, which sets the minimum Schmidt value cutoff. Additionally, the `norm_tol` parameter sets the maximum norm error above which the wavefunction is recanonicalized. " + "Currently, our wavefunction ansatz operator is an instance of the `UCJOpSpinBalanced` class. In a future guide, we will show in detail how we can use such an ansatz to build and transpile Qiskit quantum circuits. In this guide, we will use this ansatz operator to construct our wavefunction as a TeNPy MPS, which respects the fermionic symmetries. Behind the scenes, this executes the ansatz as a fermionic circuit using the TEBD algorithm. \n", + "\n", + "We can pass the `options` dictionary and `norm_tol` to the `lucj_circuit_as_mps` function to control the accuracy of our MPS approximation. The `options` parameter is detailed in the [TeNPy TEBDEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.tebd.TEBDEngine.html#tenpy.algorithms.tebd.TEBDEngine). The `norm_tol` parameter is defined in other contexts in the TeNPy library, e.g. in the [TeNPy DMRGEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.dmrg.DMRGEngine.html#cfg-option-DMRGEngine.norm_tol). The most relevant key for us in the `options` dictionary is `trunc_params`, which defines the truncation parameters for our quantum circuit. In particular, `chi_max` sets the maximum bond dimension, and `svd_min` sets the minimum Schmidt value cutoff. We also introduce the `norm_tol` parameter, which sets the maximum norm error above which the wavefunction is recanonicalized.\n", + "\n", + "In addition to the wavefunction as an MPS, the `lucj_circuit_as_mps` function also returns `chi_list`, which is a list of MPS bond dimensions that is stored after each two-site gate is applied to our initial Hartree-Fock state. This gives us an indication of how the entanglement grows in the system as we run our circuit. In the example below, we set the maximum allowed bond dimension to 15, and after running the circuit, we can see that the maximum bond dimension reaches 15. This indicates that we have most likely truncated the bond dimension with our choice of `chi_max`." ] }, { "cell_type": "code", + "execution_count": 5, "id": "e9d8e1b09ee778c2", "metadata": { "ExecuteTime": { @@ -210,23 +271,31 @@ "start_time": "2024-10-27T13:48:21.730120Z" } }, - "source": [ - "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", - "\n", - "trunc_params = {\"chi_max\": 16, \"svd_min\": 1e-6}\n", - "psi_mps = lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5)\n", - "print(\"wavefunction type = \", type(psi_mps))" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "wavefunction type = \n" + "wavefunction type = \n", + "MPS, L=4, bc='finite'.\n", + "chi: [4, 15, 4]\n", + "sites: SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000)\n", + "forms: (0.0, 1.0) (0.0, 1.0) (0.0, 1.0) (0.0, 1.0)\n", + "maximum MPS bond dimension = 15\n" ] } ], - "execution_count": 10 + "source": [ + "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", + "\n", + "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", + "psi_mps, chi_list = lucj_circuit_as_mps(\n", + " norb, nelec, lucj_operator, options, norm_tol=1e-5\n", + ")\n", + "print(\"wavefunction type = \", type(psi_mps))\n", + "print(psi_mps)\n", + "print(\"maximum MPS bond dimension = \", np.max(chi_list))" + ] }, { "cell_type": "markdown", @@ -246,6 +315,7 @@ }, { "cell_type": "code", + "execution_count": 6, "id": "a6a7d85060f3d8a2", "metadata": { "ExecuteTime": { @@ -253,6 +323,17 @@ "start_time": "2024-10-27T13:48:22.629846Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LUCJ (MPS) energy = -77.77532190749356\n", + "LUCJ energy = -77.8465101865335\n", + "FCI energy = -77.87421656438627\n" + ] + } + ], "source": [ "import numpy as np\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister\n", @@ -274,32 +355,111 @@ "# Print the FCI energy\n", "fci_energy = mol_data.fci_energy\n", "print(\"FCI energy = \", fci_energy)" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "LUCJ (MPS) energy = -77.84651018653355\n", - "LUCJ energy = -77.82366375743965\n", - "FCI energy = -77.87421656438633\n" - ] - } - ], - "execution_count": 11 + ] }, { - "cell_type": "code", - "id": "60437fea79a57ec0", + "cell_type": "markdown", + "id": "76da0123-c376-484e-9f78-231d049fc051", "metadata": { "ExecuteTime": { "end_time": "2024-10-27T13:48:22.764638Z", "start_time": "2024-10-27T13:48:22.762324Z" } }, - "source": [], - "outputs": [], - "execution_count": null + "source": [ + "In order to illustrate the effects of the truncation parameters more clearly, we can plot the energies at different values of `svd_min` and `chi_max`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bf98d538-c182-4ede-917f-1eed31969c9a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.gridspec as gridspec\n", + "\n", + "svd_min_list = [1e-3, 1e-6]\n", + "chi_max_list = np.arange(2, 21, 2)\n", + "lucj_mps_energy = np.zeros((2, len(chi_max_list)))\n", + "max_chi = np.zeros((2, len(chi_max_list)))\n", + "\n", + "for i, svd_min in enumerate(svd_min_list):\n", + " options[\"trunc_params\"][\"svd_min\"] = svd_min\n", + " for j, chi_max in enumerate(chi_max_list):\n", + " options[\"trunc_params\"][\"chi_max\"] = int(chi_max)\n", + " psi_mps, chi_list = lucj_circuit_as_mps(\n", + " norb, nelec, lucj_operator, options, norm_tol=1e-5\n", + " )\n", + " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", + " max_chi[i, j] = np.max(chi_list)\n", + "\n", + "fig = plt.figure(figsize=(10, 4))\n", + "gs = gridspec.GridSpec(1, 2, wspace=0.3)\n", + "ax0 = plt.subplot(gs[0])\n", + "ax1 = plt.subplot(gs[1])\n", + "\n", + "for i in [0, 1]:\n", + " ax0.plot(\n", + " chi_max_list,\n", + " lucj_mps_energy[i, :],\n", + " \".-\",\n", + " label=f\"$\\\\lambda_\\\\text{{min}}=10^{{{np.log10(svd_min_list[i]):g}}}$\",\n", + " )\n", + " ax0.axvline(\n", + " x=np.max(max_chi[i, :]),\n", + " c=f\"C{i}\",\n", + " linestyle=\"dashed\",\n", + " label=f\"$\\\\chi_\\\\text{{max}}(10^{{{np.log10(svd_min_list[i]):g}}})$\",\n", + " )\n", + "\n", + "ax0.set_xlabel(\"maximum MPS bond dimension\")\n", + "ax0.set_ylabel(\"$E$\")\n", + "ax0.xaxis.set_major_locator(MaxNLocator(integer=True))\n", + "ax0.axhline(y=lucj_energy, color=\"k\", linestyle=\"dashed\", label=\"$E_\\\\text{LUCJ}$\")\n", + "ax0.axhline(y=fci_energy, color=\"k\", linestyle=\"dotted\", label=\"$E_\\\\text{FCI}$\")\n", + "ax0.legend(loc=\"best\")\n", + "\n", + "for i in [0, 1]:\n", + " ax1.plot(\n", + " chi_max_list,\n", + " np.abs(np.subtract(lucj_mps_energy[i, :], lucj_energy)),\n", + " \".-\",\n", + " label=f\"$\\\\lambda_\\\\text{{min}}=10^{{{np.log10(svd_min_list[i]):g}}}$\",\n", + " )\n", + " ax1.axvline(\n", + " x=np.max(max_chi[i, :]),\n", + " c=f\"C{i}\",\n", + " linestyle=\"dashed\",\n", + " label=f\"$\\\\chi_\\\\text{{max}}(10^{{{np.log10(svd_min_list[i]):g}}})$\",\n", + " )\n", + "ax1.set_xlabel(\"maximum MPS bond dimension\")\n", + "ax1.set_ylabel(\"$|E-E_\\\\text{LUCJ}|$\")\n", + "ax1.xaxis.set_major_locator(MaxNLocator(integer=True))\n", + "ax1.set_yscale(\"log\")\n", + "ax1.legend(loc=\"best\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b2f8fbd2-b019-4d38-a4f1-62afcf238e3c", + "metadata": {}, + "source": [ + "From the above plots, we can see that above an MPS bond dimension of 16, the MPS representation of the LUCJ circuit is exact." + ] } ], "metadata": { @@ -318,7 +478,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.15" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 43f87af4f..ca3d47fb8 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -16,7 +16,7 @@ # from tenpy.models.hubbard import FermiHubbardChain -def lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5): +def lucj_circuit_as_mps(norb, nelec, lucj_operator, options, norm_tol=1e-5): r"""Return the LUCJ circuit as an MPS. Args: @@ -25,7 +25,7 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5) spinless system, or a pair of integers storing the numbers of spin alpha and spin beta fermions. lucj_operator: The LUCJ operator. - trunc_params: The truncation parameters for the TEBD gates, as defined in the + options: The parameters passed to the TEBDEngine, as defined in the TeNPy documentation. norm_tol: The norm error above which we recanonicalize the wavefunction, as defined in the TeNPy documentation. @@ -49,10 +49,7 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5) circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_operator), qubits) # define the TEBD engine - # dummy_model = FermiHubbardChain( - # {'cons_N': 'N', 'cons_Sz': 'Sz', 'L': 2 * norb, 't': 1, 'U': 2, 'mu': 0, - # 'V': 0, 'bc_x': 'open', 'bc_MPS': 'finite'}) - eng = TEBDEngine(psi, None, {"trunc_params": trunc_params}) + eng = TEBDEngine(psi, None, options) # execute the tenpy circuit for ins in circuit.decompose(reps=2): @@ -115,4 +112,4 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, trunc_params, norm_tol=1e-5) else: raise ValueError(f"gate {ins.operation.name} not implemented.") - return psi + return psi, chi_list From e0b26dcaa6b4d5e1a0dea228369db17bb69fa34c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 12:15:35 +0100 Subject: [PATCH 08/88] clean-up code --- docs/api/ffsim.tenpy.rst | 7 ++ docs/api/index.md | 1 + docs/how-to-guides/lucj_mps.ipynb | 2 +- python/ffsim/__init__.py | 3 +- python/ffsim/tenpy/__init__.py | 37 ++++++ python/ffsim/tenpy/circuits/__init__.py | 9 ++ python/ffsim/tenpy/circuits/gates.py | 133 ++++++++++++++++++-- python/ffsim/tenpy/circuits/lucj_circuit.py | 53 ++++---- 8 files changed, 208 insertions(+), 37 deletions(-) create mode 100644 docs/api/ffsim.tenpy.rst create mode 100644 python/ffsim/tenpy/__init__.py create mode 100644 python/ffsim/tenpy/circuits/__init__.py diff --git a/docs/api/ffsim.tenpy.rst b/docs/api/ffsim.tenpy.rst new file mode 100644 index 000000000..7e6361615 --- /dev/null +++ b/docs/api/ffsim.tenpy.rst @@ -0,0 +1,7 @@ +ffsim.tenpy +=========== + +.. automodule:: ffsim.tenpy + :members: + :special-members: + :show-inheritance: diff --git a/docs/api/index.md b/docs/api/index.md index 99a780e17..21c172dee 100644 --- a/docs/api/index.md +++ b/docs/api/index.md @@ -9,5 +9,6 @@ ffsim.linalg ffsim.optimize ffsim.qiskit ffsim.random +ffsim.tenpy ffsim.testing ``` diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index a9cb2b426..ccc2e26a8 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -367,7 +367,7 @@ } }, "source": [ - "In order to illustrate the effects of the truncation parameters more clearly, we can plot the energies at different values of `svd_min` and `chi_max`." + "To illustrate the effects of the truncation parameters more clearly, we can plot the energies at different values of `svd_min` and `chi_max`." ] }, { diff --git a/python/ffsim/__init__.py b/python/ffsim/__init__.py index 75fa2673f..d7445fb9d 100644 --- a/python/ffsim/__init__.py +++ b/python/ffsim/__init__.py @@ -10,7 +10,7 @@ """ffsim is a software library for fast simulation of fermionic quantum circuits.""" -from ffsim import contract, linalg, optimize, qiskit, random, testing +from ffsim import contract, linalg, optimize, qiskit, random, tenpy, testing from ffsim.cistring import init_cache from ffsim.gates import ( apply_diag_coulomb_evolution, @@ -175,6 +175,7 @@ "optimize", "qiskit", "random", + "tenpy", "rdm", "rdms", "sample_slater_determinant", diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py new file mode 100644 index 000000000..675d77543 --- /dev/null +++ b/python/ffsim/tenpy/__init__.py @@ -0,0 +1,37 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Code that uses TeNPy, e.g. for emulating quantum circuits.""" + +from ffsim.tenpy.circuits.gates import ( + cphase, + cphase_onsite, + gate1, + gate2, + phase, + sym_cons_basis, + xy, +) +from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps +from ffsim.tenpy.hamiltonians.lattices import MolecularChain +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel + +__all__ = [ + "MolecularChain", + "MolecularHamiltonianMPOModel", + "sym_cons_basis", + "xy", + "phase", + "cphase_onsite", + "cphase", + "gate1", + "gate2", + "lucj_circuit_as_mps", +] diff --git a/python/ffsim/tenpy/circuits/__init__.py b/python/ffsim/tenpy/circuits/__init__.py new file mode 100644 index 000000000..5f2c9d9c1 --- /dev/null +++ b/python/ffsim/tenpy/circuits/__init__.py @@ -0,0 +1,9 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index e2ed8042f..20e778b24 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -1,12 +1,12 @@ import numpy as np import scipy as sp -import tenpy.linalg.np_conserved as npc # TeNPy wrapper around numpy +import tenpy +import tenpy.linalg.np_conserved as npc from tenpy.linalg.charges import LegPipe from tenpy.networks.site import SpinHalfFermionSite -# ignore lowercase function, argument, and variable checks to maintain TeNPy naming -# conventions -# ruff: noqa: N802, N803, N806 +# ignore lowercase argument and variable checks to maintain TeNPy naming conventions +# ruff: noqa: N803, N806 # define sites shfs_nosym = SpinHalfFermionSite(cons_N=None, cons_Sz=None) @@ -14,7 +14,16 @@ shfsc = LegPipe([shfs.leg, shfs.leg]) -def sym_cons_basis(gate): +def sym_cons_basis(gate: np.ndarray) -> np.ndarray: + r"""Convert a gate to the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + + Args: + gate: The quantum gate. + + Returns: + The quantum gate in the (N, Sz)-symmetry-conserved basis. + """ + # convert to (N, Sz)-symmetry-conserved basis if np.shape(gate) == (4, 4): # 1-site gate swap_list = [1, 3, 0, 2] @@ -34,7 +43,24 @@ def sym_cons_basis(gate): return gate_sym -def XXPlusYY(spin, theta, beta, conj=False): +def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: + r"""The XXPlusYY gate. + + The XXPlusYY gate as defined in the + `Qiskit documentation `__, + returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + + Args: + spin: The spin sector ("up" or "down"). + theta: The rotation angle. + beta: The phase angle. + conj: The direction of the gate. By default, we use the little endian + convention, as in Qiskit. + + Returns: + The XXPlusYY gate in the (N, Sz)-symmetry-conserved basis. + """ + # define conjugate operator if conj: beta = -beta @@ -94,7 +120,21 @@ def XXPlusYY(spin, theta, beta, conj=False): return XYgate_sym -def Phase(spin, theta): +def phase(spin: str, theta: float) -> np.ndarray: + r"""The Phase gate. + + The Phase gate as defined in the + `Qiskit documentation `__, + returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + + Args: + spin: The spin sector ("up" or "down"). + theta: The rotation angle. + + Returns: + The Phase gate in the (N, Sz)-symmetry-conserved basis. + """ + # define operators Id = shfs_nosym.get_op("Id").to_ndarray() @@ -119,7 +159,20 @@ def Phase(spin, theta): return Pgate_sym -def CPhase_onsite(theta): +def cphase_onsite(theta: float) -> np.ndarray: + r"""The on-site CPhase gate. + + The on-site CPhase gate as defined in the + `Qiskit documentation `__, + returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + + Args: + theta: The rotation angle. + + Returns: + The on-site CPhase gate in the (N, Sz)-symmetry-conserved basis. + """ + CPgate = np.eye(4, dtype=complex) CPgate[3, 3] = np.exp(-1j * theta) # minus sign @@ -129,7 +182,21 @@ def CPhase_onsite(theta): return CPgate_sym -def CPhase(spin, theta): +def cphase(spin: str, theta: float) -> np.ndarray: + r"""The off-site CPhase gate. + + The off-site CPhase gate as defined in the + `Qiskit documentation `__, + returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + + Args: + spin: The spin sector ("up" or "down"). + theta: The rotation angle. + + Returns: + The off-site CPhase gate in the (N, Sz)-symmetry-conserved basis. + """ + # define operators Id = shfs_nosym.get_op("Id").to_ndarray() @@ -176,13 +243,56 @@ def CPhase(spin, theta): return CPgate_sym -def gate1(U1, site, psi): +def gate1(U1: np.ndarray, site: int, psi: tenpy.networks.mps.MPS) -> None: + r"""Apply a single-site gate to a + `TeNPy MPS `__ + wavefunction. + + Args: + U1: The single-site quantum gate. + site: The gate will be applied to `site` on the + `TeNPy MPS `__ + wavefunction. + psi: The wavefunction MPS. + + Returns: + None + """ + # on-site U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) psi.apply_local_op(site, U1_npc) -def gate2(U2, site, psi, eng, chi_list, norm_tol): +def gate2( + U2: np.ndarray, + site: int, + psi: tenpy.networks.mps.MPS, + eng: tenpy.algorithms.tebd.TEBDEngine, + chi_list: list, + norm_tol: float, +) -> None: + r"""Apply a two-site gate to a `TeNPy MPS `__ + wavefunction. + + Args: + U2: The two-site quantum gate. + site: The gate will be applied to `(site-1, site)` on the `TeNPy MPS `__ + wavefunction. + psi: The `TeNPy MPS `__ + wavefunction. + eng: The + `TeNPy TEBDEngine `__. + chi_list: The list to which to append the MPS bond dimensions as the circuit is + evaluated. + norm_tol: The norm error above which we recanonicalize the wavefunction, as + defined in the + `TeNPy documentation `__. + + Returns: + None + """ + # bond between (site-1, site) U2_npc = npc.Array.from_ndarray( U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] @@ -193,5 +303,4 @@ def gate2(U2, site, psi, eng, chi_list, norm_tol): # recanonicalize psi if below error threshold if np.linalg.norm(psi.norm_test()) > norm_tol: - # print("norm error = ", np.linalg.norm(psi.norm_test())) psi.canonical_form_finite() diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index ca3d47fb8..23baca52e 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -1,44 +1,51 @@ +from typing import Tuple + import numpy as np +import tenpy from qiskit.circuit import QuantumCircuit, QuantumRegister from tenpy.algorithms.tebd import TEBDEngine import ffsim from ffsim.tenpy.circuits.gates import ( - CPhase, - CPhase_onsite, - Phase, - XXPlusYY, + cphase, + cphase_onsite, gate1, gate2, + phase, + xy, ) from ffsim.tenpy.util import product_state_as_mps -# from tenpy.models.hubbard import FermiHubbardChain - -def lucj_circuit_as_mps(norb, nelec, lucj_operator, options, norm_tol=1e-5): - r"""Return the LUCJ circuit as an MPS. +def lucj_circuit_as_mps( + norb: int, + nelec: tuple, + lucj_operator: ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced, + options: dict, + norm_tol: float = 1e-5, +) -> Tuple[tenpy.networks.mps.MPS, list[int]]: + r"""Construct the LUCJ circuit as an MPS. Args: norb: The number of spatial orbitals. - nelec: Either a single integer representing the number of fermions for a - spinless system, or a pair of integers storing the numbers of spin alpha - and spin beta fermions. + nelec: The number of alpha and beta electrons. lucj_operator: The LUCJ operator. - options: The parameters passed to the TEBDEngine, as defined in the - TeNPy documentation. + options: The options parsed by the + `TeNPy TEBDEngine `__. norm_tol: The norm error above which we recanonicalize the wavefunction, as - defined in the TeNPy documentation. + defined in the + `TeNPy documentation `__. - Return type: + Returns: `TeNPy MPS `__ + LUCJ circuit as an MPS. - Returns: - The LUCJ circuit as an MPS. + list + Complete list of MPS bond dimensions compiled during circuit evaluation. """ # initialize chi_list - chi_list = [] + chi_list: list[int] = [] # prepare initial Hartree-Fock state psi = product_state_as_mps(norb, nelec, 0) @@ -58,7 +65,7 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, options, norm_tol=1e-5): idx = qubit._index spin_flag = "up" if idx < norb else "down" lmbda = ins.operation.params[0] - gate1(Phase(spin_flag, lmbda), idx % norb, psi) + gate1(phase(spin_flag, lmbda), idx % norb, psi) elif ins.operation.name == "xx_plus_yy": qubit0 = ins.qubits[0] qubit1 = ins.qubits[1] @@ -74,7 +81,7 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, options, norm_tol=1e-5): # directionality important when beta!=0 conj_flag = True if idx0 > idx1 else False gate2( - XXPlusYY(spin_flag, theta_val, beta_val, conj_flag), + xy(spin_flag, theta_val, beta_val, conj_flag), max(idx0 % norb, idx1 % norb), psi, eng, @@ -88,16 +95,16 @@ def lucj_circuit_as_mps(norb, nelec, lucj_operator, options, norm_tol=1e-5): lmbda = ins.operation.params[0] # onsite (different spins) if np.abs(idx0 - idx1) == norb: - gate1(CPhase_onsite(lmbda), min(idx0, idx1), psi) + gate1(cphase_onsite(lmbda), min(idx0, idx1), psi) # NN (up spins) elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: gate2( - CPhase("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol + cphase("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol ) # NN (down spins) elif np.abs(idx0 - idx1) == 1 and idx0 >= norb and idx1 >= norb: gate2( - CPhase("down", lmbda), + cphase("down", lmbda), max(idx0 % norb, idx1 % norb), psi, eng, From a96b5e3e079e0ab4c4f3b07d1364db9afa2c2c92 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 14:38:16 +0100 Subject: [PATCH 09/88] fix docstrings --- .../hamiltonians/molecular_hamiltonian.py | 10 ++--- python/ffsim/tenpy/__init__.py | 8 ++-- python/ffsim/tenpy/circuits/gates.py | 40 +++++++++++-------- python/ffsim/tenpy/circuits/lucj_circuit.py | 14 +++---- .../hamiltonians/molecular_hamiltonian.py | 2 +- 5 files changed, 41 insertions(+), 33 deletions(-) diff --git a/python/ffsim/hamiltonians/molecular_hamiltonian.py b/python/ffsim/hamiltonians/molecular_hamiltonian.py index a5e3db8de..baedee3db 100644 --- a/python/ffsim/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/hamiltonians/molecular_hamiltonian.py @@ -17,6 +17,7 @@ import numpy as np import pyscf.ao2mo import pyscf.tools +import tenpy from opt_einsum import contract from pyscf.fci.direct_nosym import absorb_h1e, contract_2e, make_hdiag from scipy.sparse.linalg import LinearOperator @@ -121,16 +122,15 @@ def rotated(self, orbital_rotation: np.ndarray) -> MolecularHamiltonian: constant=self.constant, ) - def to_mpo(self, decimal_places=None): + def to_mpo(self, decimal_places: int | None = None) -> tenpy.networks.mpo.MPO: r"""Return the Hamiltonian as an MPO. Args: decimal_places: The number of decimal places to which to round the input - one-body and two-body tensors. Rounding can sometimes reduce the MPO - bond dimension. + one-body and two-body tensors. - Return type: - `TeNPy MPO `__ + .. note:: + Rounding may reduce the MPO bond dimension. Returns: The Hamiltonian as an MPO. diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 675d77543..c2232ecf0 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -11,8 +11,8 @@ """Code that uses TeNPy, e.g. for emulating quantum circuits.""" from ffsim.tenpy.circuits.gates import ( - cphase, - cphase_onsite, + cphase1, + cphase2, gate1, gate2, phase, @@ -29,8 +29,8 @@ "sym_cons_basis", "xy", "phase", - "cphase_onsite", - "cphase", + "cphase1", + "cphase2", "gate1", "gate2", "lucj_circuit_as_mps", diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 20e778b24..0bab77cd7 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -15,13 +15,13 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: - r"""Convert a gate to the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + r"""Convert a gate to the TeNPy (N, Sz)-symmetry-conserved basis. Args: gate: The quantum gate. Returns: - The quantum gate in the (N, Sz)-symmetry-conserved basis. + The quantum gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ # convert to (N, Sz)-symmetry-conserved basis @@ -48,7 +48,7 @@ def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: The XXPlusYY gate as defined in the `Qiskit documentation `__, - returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: spin: The spin sector ("up" or "down"). @@ -58,7 +58,7 @@ def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: convention, as in Qiskit. Returns: - The XXPlusYY gate in the (N, Sz)-symmetry-conserved basis. + The XXPlusYY gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ # define conjugate operator @@ -125,14 +125,14 @@ def phase(spin: str, theta: float) -> np.ndarray: The Phase gate as defined in the `Qiskit documentation `__, - returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: spin: The spin sector ("up" or "down"). theta: The rotation angle. Returns: - The Phase gate in the (N, Sz)-symmetry-conserved basis. + The Phase gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ # define operators @@ -159,18 +159,22 @@ def phase(spin: str, theta: float) -> np.ndarray: return Pgate_sym -def cphase_onsite(theta: float) -> np.ndarray: - r"""The on-site CPhase gate. +def cphase1(theta: float) -> np.ndarray: + r"""The single-site CPhase gate. - The on-site CPhase gate as defined in the + The single-site CPhase gate as defined in the `Qiskit documentation `__, - returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + returned in the TeNPy (N, Sz)-symmetry-conserved basis. + + .. note:: + A two-site CPhase gate in the qubit basis may translate to a single-site CPhase + gate in the fermion basis. Args: theta: The rotation angle. Returns: - The on-site CPhase gate in the (N, Sz)-symmetry-conserved basis. + The single-site CPhase gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ CPgate = np.eye(4, dtype=complex) @@ -182,19 +186,23 @@ def cphase_onsite(theta: float) -> np.ndarray: return CPgate_sym -def cphase(spin: str, theta: float) -> np.ndarray: - r"""The off-site CPhase gate. +def cphase2(spin: str, theta: float) -> np.ndarray: + r"""The two-site CPhase gate. - The off-site CPhase gate as defined in the + The two-site CPhase gate as defined in the `Qiskit documentation `__, - returned in the (N, Sz)-symmetry-conserved basis, as defined in TeNPy. + returned in the TeNPy (N, Sz)-symmetry-conserved basis. + + .. note:: + A two-site CPhase gate in the qubit basis may translate to a single-site CPhase + gate in the fermion basis. Args: spin: The spin sector ("up" or "down"). theta: The rotation angle. Returns: - The off-site CPhase gate in the (N, Sz)-symmetry-conserved basis. + The two-site CPhase gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ # define operators diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 23baca52e..8535f1d46 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -7,8 +7,8 @@ import ffsim from ffsim.tenpy.circuits.gates import ( - cphase, - cphase_onsite, + cphase1, + cphase2, gate1, gate2, phase, @@ -20,7 +20,7 @@ def lucj_circuit_as_mps( norb: int, nelec: tuple, - lucj_operator: ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced, + lucj_operator: "ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced", options: dict, norm_tol: float = 1e-5, ) -> Tuple[tenpy.networks.mps.MPS, list[int]]: @@ -40,7 +40,7 @@ def lucj_circuit_as_mps( `TeNPy MPS `__ LUCJ circuit as an MPS. - list + list[int] Complete list of MPS bond dimensions compiled during circuit evaluation. """ @@ -95,16 +95,16 @@ def lucj_circuit_as_mps( lmbda = ins.operation.params[0] # onsite (different spins) if np.abs(idx0 - idx1) == norb: - gate1(cphase_onsite(lmbda), min(idx0, idx1), psi) + gate1(cphase1(lmbda), min(idx0, idx1), psi) # NN (up spins) elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: gate2( - cphase("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol + cphase2("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol ) # NN (down spins) elif np.abs(idx0 - idx1) == 1 and idx0 >= norb and idx1 >= norb: gate2( - cphase("down", lmbda), + cphase2("down", lmbda), max(idx0 % norb, idx1 % norb), psi, eng, diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index c380d3e4b..0e71c4ed2 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -9,7 +9,7 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): - """Molecular Hamiltonian MPOModel.""" + """Molecular Hamiltonian.""" def __init__(self, params): CouplingMPOModel.__init__(self, params) From c9a93beb472f430f0a322f8f99b922bd7f7aabef Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 14:47:45 +0100 Subject: [PATCH 10/88] fix docstring 2 --- python/ffsim/tenpy/__init__.py | 2 ++ python/ffsim/tenpy/util.py | 8 +++++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index c2232ecf0..3a61c5ac0 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -22,6 +22,7 @@ from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps from ffsim.tenpy.hamiltonians.lattices import MolecularChain from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.util import product_state_as_mps __all__ = [ "MolecularChain", @@ -34,4 +35,5 @@ "gate1", "gate2", "lucj_circuit_as_mps", + "product_state_as_mps", ] diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index e400af607..d66f0c808 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -4,11 +4,13 @@ import ffsim -def product_state_as_mps(norb, nelec, idx): +def product_state_as_mps(norb: int, nelec: int | tuple, idx: int) -> MPS: r"""Return the product state as an MPS. - Return type: - `TeNPy MPS `__ + Args: + norb: The number of spatial orbitals. + nelec: The number of alpha and beta electrons. + idx: The index of the product state in the ffsim basis. Returns: The product state as an MPS. From 0103d4793bb829bba7c10da7773191218638ac0c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 14:55:39 +0100 Subject: [PATCH 11/88] import annotations --- python/ffsim/tenpy/util.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index d66f0c808..a399933f1 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite From 28de05f195366757df8cb68004413ce81ebd4923 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 28 Oct 2024 15:04:44 +0100 Subject: [PATCH 12/88] fix docstring 3 --- python/ffsim/tenpy/util.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index a399933f1..b401e9add 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -1,12 +1,14 @@ from __future__ import annotations +from typing import Tuple + from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite import ffsim -def product_state_as_mps(norb: int, nelec: int | tuple, idx: int) -> MPS: +def product_state_as_mps(norb: int, nelec: int | Tuple[int, int], idx: int) -> MPS: r"""Return the product state as an MPS. Args: From c32dc853bb634a01aec7eadfef6d8bca492715f4 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 14:07:09 +0100 Subject: [PATCH 13/88] fix molecular Hamiltonian MPO conversion --- .../hamiltonians/molecular_hamiltonian.py | 4 +- .../molecular_hamiltonian_test.py | 11 +-- tests/python/tenpy/lucj_circuit_test.py | 89 +++++++++++++++++++ 3 files changed, 94 insertions(+), 10 deletions(-) create mode 100644 tests/python/tenpy/lucj_circuit_test.py diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 0e71c4ed2..7eb4f3bf5 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -38,7 +38,7 @@ def init_terms(self, params): for p in range(norb): for q in range(norb): - h1 = one_body_tensor[p, q] + h1 = one_body_tensor[q, p] if p == q: self.add_onsite(h1, p, "Nu") self.add_onsite(h1, p, "Nd") @@ -49,7 +49,7 @@ def init_terms(self, params): for r in range(norb): for s in range(norb): - h2 = two_body_tensor[p, q, r, s] + h2 = two_body_tensor[q, p, s, r] if p == q == r == s: self.add_onsite(h2 / 2, p, "Nu") self.add_onsite(-h2 / 2, p, "Nu Nu") diff --git a/tests/python/hamiltonians/molecular_hamiltonian_test.py b/tests/python/hamiltonians/molecular_hamiltonian_test.py index a04cf58a5..b73fd5b42 100644 --- a/tests/python/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/hamiltonians/molecular_hamiltonian_test.py @@ -181,13 +181,8 @@ def test_to_mpo(norb: int, nelec: tuple[int, int]): rng = np.random.default_rng() # generate a random molecular Hamiltonian - one_body_tensor = ffsim.random.random_hermitian(norb, seed=rng) - two_body_tensor = ffsim.random.random_two_body_tensor(norb, seed=rng) - constant = rng.standard_normal() - mol_hamiltonian = ffsim.MolecularHamiltonian( - one_body_tensor, two_body_tensor, constant=constant - ) - linop = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) # convert molecular Hamiltonian to MPO mol_hamiltonian_mpo = mol_hamiltonian.to_mpo() @@ -202,7 +197,7 @@ def test_to_mpo(norb: int, nelec: tuple[int, int]): product_state_mps = product_state_as_mps(norb, nelec, idx) # test expectation is preserved - original_expectation = np.vdot(product_state, linop @ product_state) + original_expectation = np.vdot(product_state, hamiltonian @ product_state) mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(product_state_mps) np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py new file mode 100644 index 000000000..cf0161637 --- /dev/null +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -0,0 +1,89 @@ +import numpy as np +import pytest +from qiskit.circuit import QuantumCircuit, QuantumRegister + +import ffsim +from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps + + +def _interaction_pairs_spin_balanced_( + connectivity: str, norb: int +) -> tuple[list[tuple[int, int]] | None, list[tuple[int, int]] | None]: + """Returns alpha-alpha and alpha-beta diagonal Coulomb interaction pairs.""" + if connectivity == "square": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb)] + elif connectivity == "hex": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb) if p % 2 == 0] + elif connectivity == "heavy-hex": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb) if p % 4 == 0] + else: + raise ValueError(f"Invalid connectivity: {connectivity}") + return pairs_aa, pairs_ab + + +@pytest.mark.parametrize( + "norb, nelec, connectivity", + [ + (4, (2, 2), "square"), + (4, (1, 2), "square"), + (4, (0, 2), "square"), + (4, (0, 0), "square"), + (4, (2, 2), "hex"), + (4, (1, 2), "hex"), + (4, (0, 2), "hex"), + (4, (0, 0), "hex"), + (4, (2, 2), "heavy-hex"), + (4, (1, 2), "heavy-hex"), + (4, (0, 2), "heavy-hex"), + (4, (0, 0), "heavy-hex"), + ], +) +def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: str): + """Test LUCJ circuit MPS construction.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo = mol_hamiltonian.to_mpo() + + # generate a random LUCJ ansatz + n_params = ffsim.UCJOpSpinBalanced.n_params( + norb=norb, + n_reps=1, + interaction_pairs=_interaction_pairs_spin_balanced_( + connectivity=connectivity, norb=norb + ), + with_final_orbital_rotation=True, + ) + params = rng.uniform(-10, 10, size=n_params) + lucj_op = ffsim.UCJOpSpinBalanced.from_parameters( + params, + norb=norb, + n_reps=1, + interaction_pairs=_interaction_pairs_spin_balanced_( + connectivity=connectivity, norb=norb + ), + with_final_orbital_rotation=True, + ) + + # generate the corresponding LUCJ circuit + qubits = QuantumRegister(2 * norb) + circuit = QuantumCircuit(qubits) + circuit.append(ffsim.qiskit.PrepareHartreeFockJW(norb, nelec), qubits) + circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_op), qubits) + lucj_state = ffsim.qiskit.final_state_vector(circuit).vec + + # convert LUCJ ansatz to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + wavefunction_mps, _ = lucj_circuit_as_mps(norb, nelec, lucj_op, options) + + # test expectation is preserved + original_expectation = np.real(np.vdot(lucj_state, hamiltonian @ lucj_state)) + mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(wavefunction_mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) From 5afd692836011f29ceace88fbab83d6a1b359268 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 14:26:31 +0100 Subject: [PATCH 14/88] fix type hint --- tests/python/tenpy/lucj_circuit_test.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index cf0161637..9968cf3f3 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -2,13 +2,14 @@ import pytest from qiskit.circuit import QuantumCircuit, QuantumRegister +from typing import Union import ffsim from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps def _interaction_pairs_spin_balanced_( connectivity: str, norb: int -) -> tuple[list[tuple[int, int]] | None, list[tuple[int, int]] | None]: +) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: """Returns alpha-alpha and alpha-beta diagonal Coulomb interaction pairs.""" if connectivity == "square": pairs_aa = [(p, p + 1) for p in range(norb - 1)] From b84ac2861057ec30bc0576327c8995026d514925 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 14:29:18 +0100 Subject: [PATCH 15/88] remove unused import --- tests/python/tenpy/lucj_circuit_test.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 9968cf3f3..2a7bd4c2a 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -2,7 +2,6 @@ import pytest from qiskit.circuit import QuantumCircuit, QuantumRegister -from typing import Union import ffsim from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps From 60495116a3c8821f1d36e28d15d8f15849906391 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 14:48:54 +0100 Subject: [PATCH 16/88] import ordering --- pyproject.toml | 2 +- python/ffsim/__init__.py | 2 +- python/ffsim/tenpy/__init__.py | 10 +++++----- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 3c7f11ec5..29d64a431 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,11 +26,11 @@ dependencies = [ "numpy", "opt_einsum", "orjson", + "physics-tenpy", "pyscf >= 2.7", "qiskit >= 1.1", "scipy", "typing-extensions", - "physics-tenpy" ] [project.urls] diff --git a/python/ffsim/__init__.py b/python/ffsim/__init__.py index d7445fb9d..47f164b8f 100644 --- a/python/ffsim/__init__.py +++ b/python/ffsim/__init__.py @@ -175,7 +175,6 @@ "optimize", "qiskit", "random", - "tenpy", "rdm", "rdms", "sample_slater_determinant", @@ -190,6 +189,7 @@ "spin_square", "strings_to_addresses", "strings_to_indices", + "tenpy", "testing", "trace", ] diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 3a61c5ac0..f3d12cb4a 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -25,15 +25,15 @@ from ffsim.tenpy.util import product_state_as_mps __all__ = [ - "MolecularChain", - "MolecularHamiltonianMPOModel", - "sym_cons_basis", - "xy", - "phase", "cphase1", "cphase2", "gate1", "gate2", "lucj_circuit_as_mps", + "MolecularChain", + "MolecularHamiltonianMPOModel", + "phase", "product_state_as_mps", + "sym_cons_basis", + "xy", ] From cc380c7392b0ad163f5898c60c0a3ba1e71b2063 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 14:54:30 +0100 Subject: [PATCH 17/88] fix type hint import --- docs/how-to-guides/lucj_mps.ipynb | 4 ++-- python/ffsim/hamiltonians/molecular_hamiltonian.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index ccc2e26a8..016fb5604 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -13,7 +13,7 @@ "id": "bdf3ae858d82fccb", "metadata": {}, "source": [ - "Following from the previous guide, we show how to use ffsim to simulate the [LUCJ ansatz](../explanations/lucj.ipynb) using matrix product states. In this way, we can calculate an approximation to the LUCJ energy, which is itself an approximation to the ground state energy, for an ethene molecule. This is particularly useful in complicated cases, such as for large molecules, where even the LUCJ energy cannot be computed exactly. \n", + "Following from the previous guide, we now show how to use ffsim to simulate the [LUCJ ansatz](../explanations/lucj.ipynb) using matrix product states. In this way, we can calculate an approximation to the LUCJ energy, which is itself an approximation to the ground state energy, for an ethene molecule. This is particularly useful in complicated cases, such as for large molecules, where even the LUCJ energy cannot be computed exactly. \n", "\n", "As before, let's start by building the molecule." ] @@ -254,7 +254,7 @@ "id": "5f989277d7cbbca8", "metadata": {}, "source": [ - "Currently, our wavefunction ansatz operator is an instance of the `UCJOpSpinBalanced` class. In a future guide, we will show in detail how we can use such an ansatz to build and transpile Qiskit quantum circuits. In this guide, we will use this ansatz operator to construct our wavefunction as a TeNPy MPS, which respects the fermionic symmetries. Behind the scenes, this executes the ansatz as a fermionic circuit using the TEBD algorithm. \n", + "Our wavefunction ansatz operator, on the other hand, is an instance of the `UCJOpSpinBalanced` class. In a future guide, we will show in detail how we can use such an ansatz to build and transpile Qiskit quantum circuits. In this guide, we will use this ansatz operator to construct our wavefunction as a TeNPy MPS, which respects the fermionic symmetries. Behind the scenes, this executes the ansatz as a fermionic circuit using the TEBD algorithm. \n", "\n", "We can pass the `options` dictionary and `norm_tol` to the `lucj_circuit_as_mps` function to control the accuracy of our MPS approximation. The `options` parameter is detailed in the [TeNPy TEBDEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.tebd.TEBDEngine.html#tenpy.algorithms.tebd.TEBDEngine). The `norm_tol` parameter is defined in other contexts in the TeNPy library, e.g. in the [TeNPy DMRGEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.dmrg.DMRGEngine.html#cfg-option-DMRGEngine.norm_tol). The most relevant key for us in the `options` dictionary is `trunc_params`, which defines the truncation parameters for our quantum circuit. In particular, `chi_max` sets the maximum bond dimension, and `svd_min` sets the minimum Schmidt value cutoff. We also introduce the `norm_tol` parameter, which sets the maximum norm error above which the wavefunction is recanonicalized.\n", "\n", diff --git a/python/ffsim/hamiltonians/molecular_hamiltonian.py b/python/ffsim/hamiltonians/molecular_hamiltonian.py index baedee3db..7ea7f5bc7 100644 --- a/python/ffsim/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/hamiltonians/molecular_hamiltonian.py @@ -17,10 +17,10 @@ import numpy as np import pyscf.ao2mo import pyscf.tools -import tenpy from opt_einsum import contract from pyscf.fci.direct_nosym import absorb_h1e, contract_2e, make_hdiag from scipy.sparse.linalg import LinearOperator +from tenpy.networks.mpo import MPO from typing_extensions import deprecated from ffsim.cistring import gen_linkstr_index @@ -122,7 +122,7 @@ def rotated(self, orbital_rotation: np.ndarray) -> MolecularHamiltonian: constant=self.constant, ) - def to_mpo(self, decimal_places: int | None = None) -> tenpy.networks.mpo.MPO: + def to_mpo(self, decimal_places: int | None = None) -> MPO: r"""Return the Hamiltonian as an MPO. Args: From 56159eaa6bde9a8309af5c782ae3656ce68e8825 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 15:06:43 +0100 Subject: [PATCH 18/88] fix type hints in gates.py --- python/ffsim/tenpy/circuits/gates.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 0bab77cd7..9eaf47ceb 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -1,8 +1,9 @@ import numpy as np import scipy as sp -import tenpy import tenpy.linalg.np_conserved as npc +from tenpy.algorithms.tebd import TEBDEngine from tenpy.linalg.charges import LegPipe +from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite # ignore lowercase argument and variable checks to maintain TeNPy naming conventions @@ -251,7 +252,7 @@ def cphase2(spin: str, theta: float) -> np.ndarray: return CPgate_sym -def gate1(U1: np.ndarray, site: int, psi: tenpy.networks.mps.MPS) -> None: +def gate1(U1: np.ndarray, site: int, psi: MPS) -> None: r"""Apply a single-site gate to a `TeNPy MPS `__ wavefunction. @@ -275,8 +276,8 @@ def gate1(U1: np.ndarray, site: int, psi: tenpy.networks.mps.MPS) -> None: def gate2( U2: np.ndarray, site: int, - psi: tenpy.networks.mps.MPS, - eng: tenpy.algorithms.tebd.TEBDEngine, + psi: MPS, + eng: TEBDEngine, chi_list: list, norm_tol: float, ) -> None: From 3820e25eaf98654aae9b9d708e1ace65dff5a71d Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 15:15:04 +0100 Subject: [PATCH 19/88] fix type hints in lucj_circuit.py --- python/ffsim/tenpy/circuits/lucj_circuit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 8535f1d46..b04afcdd1 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -1,9 +1,9 @@ from typing import Tuple import numpy as np -import tenpy from qiskit.circuit import QuantumCircuit, QuantumRegister from tenpy.algorithms.tebd import TEBDEngine +from tenpy.networks.mps import MPS import ffsim from ffsim.tenpy.circuits.gates import ( @@ -23,7 +23,7 @@ def lucj_circuit_as_mps( lucj_operator: "ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced", options: dict, norm_tol: float = 1e-5, -) -> Tuple[tenpy.networks.mps.MPS, list[int]]: +) -> Tuple[MPS, list[int]]: r"""Construct the LUCJ circuit as an MPS. Args: From 94b7d9326a19543ef02238a3249258d68aa3e6f0 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 15:34:33 +0100 Subject: [PATCH 20/88] fix type hint for util.py --- python/ffsim/tenpy/util.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index b401e9add..7bc902fbb 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -1,14 +1,12 @@ from __future__ import annotations -from typing import Tuple - from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite import ffsim -def product_state_as_mps(norb: int, nelec: int | Tuple[int, int], idx: int) -> MPS: +def product_state_as_mps(norb: int, nelec: int | tuple[int, int], idx: int) -> MPS: r"""Return the product state as an MPS. Args: From 18078c9c4bad08c6baf080a703f9893e1ef72b88 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 29 Oct 2024 15:38:30 +0100 Subject: [PATCH 21/88] fix another type hint in lucj_circuit.py --- python/ffsim/tenpy/circuits/lucj_circuit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index b04afcdd1..fc9b4a7a8 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -1,4 +1,4 @@ -from typing import Tuple +from __future__ import annotations import numpy as np from qiskit.circuit import QuantumCircuit, QuantumRegister @@ -23,7 +23,7 @@ def lucj_circuit_as_mps( lucj_operator: "ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced", options: dict, norm_tol: float = 1e-5, -) -> Tuple[MPS, list[int]]: +) -> tuple[MPS, list[int]]: r"""Construct the LUCJ circuit as an MPS. Args: From b980c3bece4f4a0ab1886685b59eb6324bf4f39b Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 1 Nov 2024 12:15:53 +0100 Subject: [PATCH 22/88] add from_molecular_hamiltonian static method --- docs/how-to-guides/lucj_mps.ipynb | 38 ++++++++----- .../hamiltonians/molecular_hamiltonian.py | 36 ------------ .../hamiltonians/molecular_hamiltonian.py | 48 ++++++++++++++++ .../molecular_hamiltonian_test.py | 36 ------------ tests/python/tenpy/__init__.py | 9 +++ tests/python/tenpy/lucj_circuit_test.py | 18 +++++- .../tenpy/molecular_hamiltonian_test.py | 56 +++++++++++++++++++ 7 files changed, 153 insertions(+), 88 deletions(-) create mode 100644 tests/python/tenpy/__init__.py create mode 100644 tests/python/tenpy/molecular_hamiltonian_test.py diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 016fb5604..8239afa5d 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -33,10 +33,10 @@ "name": "stdout", "output_type": "stream", "text": [ + "converged SCF energy = -77.8266321248745\n", + "Parsing /tmp/tmp2pnmz0qj\n", "converged SCF energy = -77.8266321248744\n", - "Parsing /tmp/tmpmp33ub72\n", - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374028 E_corr = -0.04758323886583927\n" + "E(CCSD) = -77.8742153637403 E_corr = -0.04758323886584472\n" ] }, { @@ -164,7 +164,7 @@ "id": "2824dff2829fccbf", "metadata": {}, "source": [ - "Currently, our Hamiltonian is an instance of the `MolecularHamiltonian` class. Using the `to_mpo` class method, we can convert this to a TeNPy MPO, which respects the fermionic symmetries. We can now use this MPO object as outlined in the [TeNPy MPO documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.networks.mpo.MPO.html#tenpy.networks.mpo.MPO). For example, the class attribute `chi` tells us the MPO bond dimension, which is an important indicator of how complicated the Hamiltonian is in an MPO representation." + "Currently, our Hamiltonian is an instance of the `MolecularHamiltonian` class. Using the `from_molecular_hamiltonian` method from the `MolecularHamiltonianMPOModel` class, we can convert this to a TeNPy `MPOModel`, which respects the fermionic symmetries. We can then construct the MPO using the `H_MPO` attribute and use this `MPO` object as outlined in the [TeNPy MPO documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.networks.mpo.MPO.html#tenpy.networks.mpo.MPO). For example, the `MPO` class attribute `chi` tells us the MPO bond dimension, which is an important indicator of how complicated the Hamiltonian is in an MPO representation." ] }, { @@ -184,13 +184,18 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 58\n" + "maximum MPO bond dimension = 54\n" ] } ], "source": [ + "from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel\n", + "\n", "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", - "hamiltonian_mpo = mol_hamiltonian.to_mpo()\n", + "hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", + " mol_hamiltonian\n", + ")\n", + "hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" ] @@ -200,7 +205,7 @@ "id": "3fd02a8e-5675-4010-b24b-41259303e16c", "metadata": {}, "source": [ - "Optionally, we can pass the `decimal_places` argument to the `to_mpo` class method, which rounds the precision of the input one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." + "Optionally, we can pass the `decimal_places` argument to the `from_molecular_hamiltonian` method, which rounds the precision of the input one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." ] }, { @@ -211,7 +216,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -228,7 +233,10 @@ "dp_list = np.arange(1, 16, dtype=int)\n", "chi_list = []\n", "for dp in dp_list:\n", - " hamiltonian_mpo = mol_hamiltonian.to_mpo(decimal_places=dp)\n", + " hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", + " mol_hamiltonian, decimal_places=dp\n", + " )\n", + " hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", " chi_list.append(max(hamiltonian_mpo.chi))\n", "\n", "fig = plt.figure()\n", @@ -328,9 +336,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77532190749356\n", - "LUCJ energy = -77.8465101865335\n", - "FCI energy = -77.87421656438627\n" + "LUCJ (MPS) energy = -77.77532190749352\n", + "LUCJ energy = -77.84651018653335\n", + "FCI energy = -77.87421656438622\n" ] } ], @@ -372,13 +380,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/python/ffsim/hamiltonians/molecular_hamiltonian.py b/python/ffsim/hamiltonians/molecular_hamiltonian.py index 7ea7f5bc7..0b6d8a721 100644 --- a/python/ffsim/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/hamiltonians/molecular_hamiltonian.py @@ -20,13 +20,11 @@ from opt_einsum import contract from pyscf.fci.direct_nosym import absorb_h1e, contract_2e, make_hdiag from scipy.sparse.linalg import LinearOperator -from tenpy.networks.mpo import MPO from typing_extensions import deprecated from ffsim.cistring import gen_linkstr_index from ffsim.operators import FermionOperator, cre_a, cre_b, des_a, des_b from ffsim.states import dim -from ffsim.tenpy.hamiltonians import MolecularHamiltonianMPOModel @dataclasses.dataclass(frozen=True) @@ -122,40 +120,6 @@ def rotated(self, orbital_rotation: np.ndarray) -> MolecularHamiltonian: constant=self.constant, ) - def to_mpo(self, decimal_places: int | None = None) -> MPO: - r"""Return the Hamiltonian as an MPO. - - Args: - decimal_places: The number of decimal places to which to round the input - one-body and two-body tensors. - - .. note:: - Rounding may reduce the MPO bond dimension. - - Returns: - The Hamiltonian as an MPO. - """ - - if decimal_places: - one_body_tensor = np.round(self.one_body_tensor, decimals=decimal_places) - two_body_tensor = np.round(self.two_body_tensor, decimals=decimal_places) - else: - one_body_tensor = self.one_body_tensor - two_body_tensor = self.two_body_tensor - - model_params = dict( - cons_N="N", - cons_Sz="Sz", - L=1, - norb=self.norb, - one_body_tensor=one_body_tensor, - two_body_tensor=two_body_tensor, - constant=self.constant, - ) - mpo_model = MolecularHamiltonianMPOModel(model_params) - - return mpo_model.H_MPO - def _linear_operator_(self, norb: int, nelec: tuple[int, int]) -> LinearOperator: """Return a SciPy LinearOperator representing the object.""" n_alpha, n_beta = nelec diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 7eb4f3bf5..16fb2974c 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -1,7 +1,10 @@ +from __future__ import annotations + import numpy as np from tenpy.models.model import CouplingMPOModel from tenpy.networks.site import SpinHalfFermionSite +from ffsim.hamiltonians.molecular_hamiltonian import MolecularHamiltonian from ffsim.tenpy.hamiltonians.lattices import MolecularChain # ignore lowercase variable checks to maintain TeNPy naming conventions @@ -12,6 +15,9 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" def __init__(self, params): + if hasattr(self, "flag"): # only call __init__ once + return + self.flag = True CouplingMPOModel.__init__(self, params) def init_sites(self, params): @@ -96,3 +102,45 @@ def init_terms(self, params): ("Cd", dx0, q), ], ) + + @staticmethod + def from_molecular_hamiltonian( + molecular_hamiltonian: MolecularHamiltonian, decimal_places: int | None = None + ) -> MolecularHamiltonianMPOModel: + r"""Convert MolecularHamiltonian to a MolecularHamiltonianMPOModel. + + Args: + molecular_hamiltonian: The molecular Hamiltonian. + decimal_places: The number of decimal places to which to round the input + one-body and two-body tensors. + + .. note:: + Rounding may reduce the MPO bond dimension. + + Returns: + The molecular Hamiltonian as a TeNPy MPOModel. + """ + + if decimal_places: + one_body_tensor = np.round( + molecular_hamiltonian.one_body_tensor, decimals=decimal_places + ) + two_body_tensor = np.round( + molecular_hamiltonian.two_body_tensor, decimals=decimal_places + ) + else: + one_body_tensor = molecular_hamiltonian.one_body_tensor + two_body_tensor = molecular_hamiltonian.two_body_tensor + + model_params = dict( + cons_N="N", + cons_Sz="Sz", + L=1, + norb=molecular_hamiltonian.norb, + one_body_tensor=one_body_tensor, + two_body_tensor=two_body_tensor, + constant=molecular_hamiltonian.constant, + ) + mpo_model = MolecularHamiltonianMPOModel(model_params) + + return mpo_model diff --git a/tests/python/hamiltonians/molecular_hamiltonian_test.py b/tests/python/hamiltonians/molecular_hamiltonian_test.py index b73fd5b42..3b594970a 100644 --- a/tests/python/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/hamiltonians/molecular_hamiltonian_test.py @@ -22,7 +22,6 @@ import scipy.sparse.linalg import ffsim -from ffsim.tenpy.util import product_state_as_mps def test_linear_operator(): @@ -167,41 +166,6 @@ def test_rotated(): np.testing.assert_allclose(original_expectation, rotated_expectation) -@pytest.mark.parametrize( - "norb, nelec", - [ - (4, (2, 2)), - (4, (1, 2)), - (4, (0, 2)), - (4, (0, 0)), - ], -) -def test_to_mpo(norb: int, nelec: tuple[int, int]): - """Test MPO conversion.""" - rng = np.random.default_rng() - - # generate a random molecular Hamiltonian - mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) - hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) - - # convert molecular Hamiltonian to MPO - mol_hamiltonian_mpo = mol_hamiltonian.to_mpo() - - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - product_state = np.zeros(dim) - product_state[idx] = 1 - - # convert product state to MPS - product_state_mps = product_state_as_mps(norb, nelec, idx) - - # test expectation is preserved - original_expectation = np.vdot(product_state, hamiltonian @ product_state) - mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(product_state_mps) - np.testing.assert_allclose(original_expectation, mpo_expectation) - - @pytest.mark.filterwarnings("ignore::DeprecationWarning") def test_from_fcidump(tmp_path: pathlib.Path): """Test loading from FCIDUMP.""" diff --git a/tests/python/tenpy/__init__.py b/tests/python/tenpy/__init__.py new file mode 100644 index 000000000..5f2c9d9c1 --- /dev/null +++ b/tests/python/tenpy/__init__.py @@ -0,0 +1,9 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 2a7bd4c2a..6b7fc2888 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -1,9 +1,22 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for LUCJ circuit TeNPy methods.""" + import numpy as np import pytest from qiskit.circuit import QuantumCircuit, QuantumRegister import ffsim from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel def _interaction_pairs_spin_balanced_( @@ -50,7 +63,10 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) # convert molecular Hamiltonian to MPO - mol_hamiltonian_mpo = mol_hamiltonian.to_mpo() + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO # generate a random LUCJ ansatz n_params = ffsim.UCJOpSpinBalanced.n_params( diff --git a/tests/python/tenpy/molecular_hamiltonian_test.py b/tests/python/tenpy/molecular_hamiltonian_test.py new file mode 100644 index 000000000..543df4bb3 --- /dev/null +++ b/tests/python/tenpy/molecular_hamiltonian_test.py @@ -0,0 +1,56 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for molecular Hamiltonian TeNPy methods.""" + +import numpy as np +import pytest + +import ffsim +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.util import product_state_as_mps + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): + """Test conversion from MolecularHamiltonian to MolecularHamiltonianMPOModel.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + product_state = np.zeros(dim) + product_state[idx] = 1 + + # convert product state to MPS + product_state_mps = product_state_as_mps(norb, nelec, idx) + + # test expectation is preserved + original_expectation = np.vdot(product_state, hamiltonian @ product_state) + mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(product_state_mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) From cd0f1ce175a9b176eccd43d4430641fdafcf6c87 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 1 Nov 2024 12:30:35 +0100 Subject: [PATCH 23/88] directly import UCJOpSpinBalanced for type hint --- python/ffsim/tenpy/circuits/lucj_circuit.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index fc9b4a7a8..dae78b48f 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -15,12 +15,13 @@ xy, ) from ffsim.tenpy.util import product_state_as_mps +from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced def lucj_circuit_as_mps( norb: int, nelec: tuple, - lucj_operator: "ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced", + ucj_op: UCJOpSpinBalanced, options: dict, norm_tol: float = 1e-5, ) -> tuple[MPS, list[int]]: @@ -29,7 +30,7 @@ def lucj_circuit_as_mps( Args: norb: The number of spatial orbitals. nelec: The number of alpha and beta electrons. - lucj_operator: The LUCJ operator. + ucj_op: The LUCJ operator. options: The options parsed by the `TeNPy TEBDEngine `__. norm_tol: The norm error above which we recanonicalize the wavefunction, as @@ -53,7 +54,7 @@ def lucj_circuit_as_mps( # construct the qiskit circuit qubits = QuantumRegister(2 * norb) circuit = QuantumCircuit(qubits) - circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_operator), qubits) + circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(ucj_op), qubits) # define the TEBD engine eng = TEBDEngine(psi, None, options) From ea4f56f01971e30564ac3edd8ae95b6f6ab84a40 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 1 Nov 2024 17:19:10 +0100 Subject: [PATCH 24/88] update notebook --- docs/how-to-guides/lucj_mps.ipynb | 84 +++++++++---------------------- 1 file changed, 24 insertions(+), 60 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 8239afa5d..6ed00f185 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -33,8 +33,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp2pnmz0qj\n", + "converged SCF energy = -77.8266321248744\n", + "Parsing /tmp/tmp08hsp77h\n", "converged SCF energy = -77.8266321248744\n", "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", @@ -45,7 +45,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_hcore get_ovlp of \n", + "Overwritten attributes get_ovlp get_hcore of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.8742153637403 E_corr = -0.04758323886584472\n" + "E(CCSD) = -77.87421536374029 E_corr = -0.04758323886585589\n" ] }, { @@ -182,9 +182,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "original Hamiltonian type = \n", - "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 54\n" + "original Hamiltonian type = \n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'MolecularHamiltonianMPOModel' object has no attribute 'H_MPO'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moriginal Hamiltonian type = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m(mol_hamiltonian))\n\u001b[1;32m 4\u001b[0m hamiltonian_mpo_model \u001b[38;5;241m=\u001b[39m \\\n\u001b[1;32m 5\u001b[0m MolecularHamiltonianMPOModel\u001b[38;5;241m.\u001b[39mfrom_molecular_hamiltonian(mol_hamiltonian)\n\u001b[0;32m----> 6\u001b[0m hamiltonian_mpo \u001b[38;5;241m=\u001b[39m \u001b[43mhamiltonian_mpo_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mH_MPO\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconverted Hamiltonian type = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m(hamiltonian_mpo))\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmaximum MPO bond dimension = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mmax\u001b[39m(hamiltonian_mpo\u001b[38;5;241m.\u001b[39mchi))\n", + "\u001b[0;31mAttributeError\u001b[0m: 'MolecularHamiltonianMPOModel' object has no attribute 'H_MPO'" ] } ], @@ -210,21 +219,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "501c1a64-576d-48c9-9018-5e2053adddd5", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -271,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "e9d8e1b09ee778c2", "metadata": { "ExecuteTime": { @@ -279,20 +277,7 @@ "start_time": "2024-10-27T13:48:21.730120Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "wavefunction type = \n", - "MPS, L=4, bc='finite'.\n", - "chi: [4, 15, 4]\n", - "sites: SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000)\n", - "forms: (0.0, 1.0) (0.0, 1.0) (0.0, 1.0) (0.0, 1.0)\n", - "maximum MPS bond dimension = 15\n" - ] - } - ], + "outputs": [], "source": [ "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", "\n", @@ -323,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "a6a7d85060f3d8a2", "metadata": { "ExecuteTime": { @@ -331,17 +316,7 @@ "start_time": "2024-10-27T13:48:22.629846Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "LUCJ (MPS) energy = -77.77532190749352\n", - "LUCJ energy = -77.84651018653335\n", - "FCI energy = -77.87421656438622\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister\n", @@ -380,21 +355,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.gridspec as gridspec\n", "\n", From e608dc5c97468f24d719254a5e59f0068372c42f Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 1 Nov 2024 17:20:52 +0100 Subject: [PATCH 25/88] update notebook 2 --- docs/how-to-guides/lucj_mps.ipynb | 93 +++++++++++++++++++++---------- 1 file changed, 64 insertions(+), 29 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 6ed00f185..cd011d5fd 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -34,9 +34,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248744\n", - "Parsing /tmp/tmp08hsp77h\n", + "Parsing /tmp/tmpkaelgp31\n", "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374029 E_corr = -0.04758323886585589\n" + "E(CCSD) = -77.87421536374029 E_corr = -0.0475832388658529\n" ] }, { @@ -182,18 +182,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "original Hamiltonian type = \n" - ] - }, - { - "ename": "AttributeError", - "evalue": "'MolecularHamiltonianMPOModel' object has no attribute 'H_MPO'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moriginal Hamiltonian type = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m(mol_hamiltonian))\n\u001b[1;32m 4\u001b[0m hamiltonian_mpo_model \u001b[38;5;241m=\u001b[39m \\\n\u001b[1;32m 5\u001b[0m MolecularHamiltonianMPOModel\u001b[38;5;241m.\u001b[39mfrom_molecular_hamiltonian(mol_hamiltonian)\n\u001b[0;32m----> 6\u001b[0m hamiltonian_mpo \u001b[38;5;241m=\u001b[39m \u001b[43mhamiltonian_mpo_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mH_MPO\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconverted Hamiltonian type = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m(hamiltonian_mpo))\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmaximum MPO bond dimension = \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mmax\u001b[39m(hamiltonian_mpo\u001b[38;5;241m.\u001b[39mchi))\n", - "\u001b[0;31mAttributeError\u001b[0m: 'MolecularHamiltonianMPOModel' object has no attribute 'H_MPO'" + "original Hamiltonian type = \n", + "converted Hamiltonian type = \n", + "maximum MPO bond dimension = 54\n" ] } ], @@ -201,9 +192,8 @@ "from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel\n", "\n", "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", - "hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", - " mol_hamiltonian\n", - ")\n", + "hamiltonian_mpo_model = \\\n", + " MolecularHamiltonianMPOModel.from_molecular_hamiltonian(mol_hamiltonian)\n", "hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" @@ -219,10 +209,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "501c1a64-576d-48c9-9018-5e2053adddd5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -231,9 +232,9 @@ "dp_list = np.arange(1, 16, dtype=int)\n", "chi_list = []\n", "for dp in dp_list:\n", - " hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", - " mol_hamiltonian, decimal_places=dp\n", - " )\n", + " hamiltonian_mpo_model = \\\n", + " MolecularHamiltonianMPOModel.from_molecular_hamiltonian(mol_hamiltonian, \n", + " decimal_places=dp)\n", " hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", " chi_list.append(max(hamiltonian_mpo.chi))\n", "\n", @@ -269,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e9d8e1b09ee778c2", "metadata": { "ExecuteTime": { @@ -277,7 +278,20 @@ "start_time": "2024-10-27T13:48:21.730120Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wavefunction type = \n", + "MPS, L=4, bc='finite'.\n", + "chi: [4, 15, 4]\n", + "sites: SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000)\n", + "forms: (0.0, 1.0) (0.0, 1.0) (0.0, 1.0) (0.0, 1.0)\n", + "maximum MPS bond dimension = 15\n" + ] + } + ], "source": [ "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", "\n", @@ -308,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a6a7d85060f3d8a2", "metadata": { "ExecuteTime": { @@ -316,7 +330,17 @@ "start_time": "2024-10-27T13:48:22.629846Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LUCJ (MPS) energy = -77.78391574155206\n", + "LUCJ energy = -77.84651018653351\n", + "FCI energy = -77.87421656438626\n" + ] + } + ], "source": [ "import numpy as np\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister\n", @@ -355,10 +379,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAFzCAYAAABcurqFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC9xElEQVR4nOzdeXhU5dn48e/MJJns+042lrCEhAQICWhBqdRIEXFrrSsgYtWi9Yf6vtAiKhV5rUuxisUqggtutYJWrWKRCiokEgwQwk4SQvZ9mewz5/fHkJGQhSRMcmaS+3Nd50rmzHOec0+2k3ue59yPRlEUBSGEEEIIIYQQA0ardgBCCCGEEEIIMdRIIiaEEEIIIYQQA0wSMSGEEEIIIYQYYJKICSGEEEIIIcQAk0RMCCGEEEIIIQaYJGJCCCGEEEIIMcAkERNCCCGEEEKIASaJmBBCCCGEEEIMMAe1AxgMTCYTBQUFeHh4oNFo1A5HCCHsiqIo1NbWEhoailYr7w/aArmuCSFE3/X0uiaJmBUUFBQQHh6udhhCCGHX8vLyCAsLUzsMgVzXhBDCGi50XZNEzAo8PDwA8xfb09NT5WiEEMK+1NTUEB4ebvlbKtQn1zUhhOi7nl7XJBGzgrZpG56ennLBEmKQazDUUvzcNACCHtqNi5skD9YiU+Bsh1zXhBg65LrWfy50XZNETAghekFRTESZ8gCoV0wqRyOEEEJcHLmuqUfuihZCCCGEEEKIASaJmBBCCCGEEEIMMJmaKIYMRVFobW3FaDSqHYoYIDqdDgcHB7n3SAxJn376KQ899BAmk4n//d//5a677lI7JCGEEOeQREwMCc3NzRQWFlJfX692KGKAubq6EhISgpOTk9qhCDFgWltbWbp0KTt27MDLy4vJkydz3XXX4efnp3ZoQgghzpJETAx6JpOJ7OxsdDodoaGhODk5yQjJEKAoCs3NzZSWlpKdnU10dLQsFiyGjLS0NMaPH8+wYcMAmD17Ntu2bePmm29WOTIhhBBtJBETg15zczMmk4nw8HBcXV3VDkcMIBcXFxwdHcnNzaW5uRlnZ+eL7lOj0VJIAADeGknsRP/YuXMnzzzzDOnp6RQWFrJlyxauvfbadm3WrVvHM888Q1FREfHx8bz44oskJSUB5gWZ25IwgGHDhpGfnz+QL0EIYSfkuqYeu/hq//e//0Wj0XS6/fDDDwA8/vjjnT7v5ubWbd+nT59mzpw5uLq6EhgYyCOPPEJra+tAvCwxwGQ0ZGiy9vfdxc2DkMdPEPL4CVlrRfQbg8FAfHw869at6/T5999/n6VLl/LYY4+xb98+4uPjSUlJoaSkZIAjFULYO7muqccuRsQuueQSCgsL2+179NFH2b59O4mJiQA8/PDD3HPPPe3aXHHFFUyZMqXLfo1GI3PmzCE4OJjvv/+ewsJC7rjjDhwdHXnqqaes/0JsWPGZk5TmZhEQGUNQ2Ei1wxFCiCFt9uzZzJ49u8vnn3/+eRYvXszChQsBWL9+PZ999hmvv/46y5YtIzQ0tN0IWH5+vmW0rDNNTU00NTVZHtfU1FjhVahLrmtCCFtnF0METk5OBAcHWzY/Pz8+/vhjFi5caLnXx93dvV2b4uJisrKyWLRoUZf9btu2jaysLN5++20SEhKYPXs2f/rTn1i3bh3Nzc0D9fJUl/bPtfi/OpnYr27D/9XJpP1zrdohCSGE6EJzczPp6enMmjXLsk+r1TJr1ix2794NQFJSEpmZmeTn51NXV8e///1vUlJSuuxzzZo1eHl5Wbbw8PB+fx39Sa5rQgh7YBeJ2Pk++eQTysvLLe8Edua1115j9OjRTJ8+vcs2u3fvJi4ujqCgIMu+lJQUampqOHToUJfHNTU1UVNT026zV8VnTjL5wOPoNAoAOo3CpANPUHzmpLqBCWGjGuvrOP5kIsefTKSxvk7tcMQQVFZWhtFobHftAggKCqKoqAgABwcHnnvuOWbOnElCQgIPPfRQtxUTly9fTnV1tWXLy8vr19fQX4ytraR+9AJTDjzW7ro25cBj7P777zmesQuj3H4gRDtyXVOPXUxNPN+GDRtISUkhLCys0+cbGxvZvHkzy5Yt67afoqKiTi9kbc91Zc2aNTzxxBO9jNo2leZmEXT2YtXGQWOiLPeITOUQohMmk5Ho1uMA1JtkTTphu6655hquueaaHrXV6/Xo9fp+jqj/1FZXcOizlwk//ibJSjGcVxhXo4FpBZtg6yaqt7pxym0izeE/IzghhYjRCWjkHmIxhMl1TT2q/uVZtmxZl0U42rYjR460O+bMmTN8+eWX3U453LJlC7W1tcyfP79f4h4s7xwCBETGYFLaX7FaFS3+kWNVikiIC6uqqiIxMZGEhARiY2N59dVX1Q5JiAHj7++PTqejuLi43f7i4mKCg4NVikod+acOs+flu9E8H8PUY88wTCmmBhdM7d9fxKRoOKifSK3ighcGJhq+JfnI/xH53kzKVo1g7/M38MNHL1CYe1SdFyKEGJJUHRF76KGHWLBgQbdtRowY0e7xxo0b8fPz6/Zdvtdee42rr766w2jX+YKDg0lLS2u3r+3C1t3FzN7fOTxXUNhI9rlfyiTDtwCYFNg34TGSZDRM2DAPDw927tyJq6srBoOB2NhYrr/+elmsVgwJTk5OTJ48me3bt1tK2ptMJrZv386SJUvUDW4AKCYTWbv/TfN3LxFv2M0wjQIayNWGUTR2AXG/vJu9X25k0oEncNCYaFW05uvaDQ/S2tLM0f3fUnHoP3gUfMeoxkMEaCoJqPkPHPgPHFhJviaIfJ8ktCMvY3jibPyCOp99I4QQF0vVRCwgIICAgIAet1cUhY0bN1oqG3YmOzubHTt28Mknn1ywv2nTprF69WpKSkoIDAwE4KuvvsLT05OYmJgex2XvjA7uls9zteEk3fCgesGITi1btoy//OUv3HDDDbzzzjtqh6M6nU5nWROuqakJRVFQFOUCRwlhP+rq6jhx4oTlcXZ2NhkZGfj6+hIREcHSpUuZP38+iYmJJCUlsXbtWgwGQ7f3Ttu7xgYDB77YgF/m64w3Zpt3auCA8xSYei+x068lUqcDIOmGBylOnktZ7hH8I8da3lx0cHRiTOLPIfHnlj4z931N7eGv8SnazaiWowyjmGEV/4KKf8EPD5OtjaTYPxnn6JmMmJKCp7e84SOEsA67ukfs66+/Jjs7m7vuuqvLNq+//johISGdlv3dsmULy5cvt0x3vPLKK4mJieH222/nz3/+M0VFRaxYsYLf/e53g2bEqyc8DTmWz8NMBTQ2GHB26X79NTGwli9fTlhYGPfffz+rVq1i1KhRaofUpZ4sRAvdL0bbE1VVVVx22WUcP36cZ555Bn9/fyu+CiHUtXfvXmbOnGl5vHTpUgDmz5/Ppk2buOmmmygtLWXlypUUFRWRkJDAF198ccGZIPaorOg0xz97gTF5H5CEuThWvaLnoP9sgq/8f0wYk9DpcUFhIy94r7Ozixuxl86FS+cCUFdTycm9X9Jw9L8ElO1hpDGb4aZchpfkQskHGL/VcMwxmvLAabiPvYLoxCtwdnXv9hxCCNEVu0rENmzYwCWXXMLYsZ3fv2Qymdi0aRMLFixAd/ZdsXNVV1dz9OhP8791Oh2ffvop9957L9OmTcPNzY358+ezatWqfnsNtkYxmQhuNd/jZlI0OGqMZB/ey+hJl6kcmTiXl5cXixYt4ve//z0HDx606USsbSHaO++8k+uvv77TNm2L0a5fv57k5GTWrl1LSkoKR48etYxOJyQkdLq4+rZt2wgNDcXb25v9+/dTXFzM9ddfz4033jgo/wkVQ9Pll19+wVHeJUuWDOqpiCf2f0vl138lvuo/TNOYCwgU4U/OiFsYN2cJyX7W/3139/Qh/ue/gZ//BoDK0kJO/fAFrSf/S2hFGuEUMLr1GBQcg4I3aN7uwCF9DDUhl+AzfhYjE2bg6DR03sgVQlwcu0rELjQlS6vVdls4Y8GCBR3uSYuMjOTzzz+3Rnh2qbKsEF8MmBQNR5zGE9OSSeXJH0ASsS4VVjeQXWZguL8bIV4uA3be1tZWXF1dyczM5Lrrrhuw8/bWhRaihQsvRguQkZHRo/MFBQURHx/Prl27uPHGGy8q9p6qxBMA+XdLCOsytrZyYPtm9Hv/TkxLpnmnBo44xmCYeDfxv7iVYEenAYvHJyCEyb9cCJj/VhXlnSAv/QvI3klk9Q8EaioY33wAcg9A7noMnzmT5TqBhmGXEjDhSoaPT6a0MEcWlhY2T65r6rCrRExYX3F2Jr5Ascaf6oBJUJCJpjBD7bD6naIoNLT0vkTrP9PP8NgnhzApoNXAE9eM54bJPb+R28VRZ1mEvLdWrFhBXV0dmZmZfTq+t5566imeeuqpbttkZWURERHRq37bFqNdvny5Zd/5i9FeSHFxMa6urnh4eFBdXc3OnTu59957exVHX7m6e+H6uP1WShXCFlVXlnH4s5eIOLmZiUoJAC2Kjv1eM/G8/H7GTrpc3QDPCg4fRXD4EmAJislE3smDFPz4JY6ndzG87kd8NLXEN6TBiTQ48RcM/9QTSBNBGvOskz2jH2bqrSvUfhlCtCPXNfVIIjbE1eWb75crdY5AHz4JCt7Ep/qwylH1v4YWIzErv7yoPkwKPPrxIR79uOvFv8+XtSoFV6fe/9qlp6ezfv165syZM2CJ2D333MOvf/3rbtuEhob2ut/uFqM9f7mKruTm5nL33XdbinTcf//9xMXF9ToWIYS68k4cpOCLvxBX+ilTNU0AVOLBkWE3MmrOgySGRqkbYDc0Wi3h0fGER8cD/4PJaOTkoVRKD2zDJf87ouv343b2NQFoNQpTjz9D2eOvUuA8inrvMehCYvEdMYmw6AnonV3VezFCCFVIIjbEtZYeA6DBYzhhY6ZCKkS25tDc1IiT3lnl6ASY73387W9/y5IlS0hOTua2226jpaWly8qhnSkoKOCRRx5h8+bNPT7G19cXX1/fvoTc75KSkno8dVEIYVsUk4nMb/+Fafc64htSCQfQQLY2ktLxC5kwezHT7LAAhlanY+SESxg54RIADu7cQtzXCzq086cK/8a9ULQXioAfzet35uiGUe4WTYvfOJzD4giKnkRwePSgW2y6+MxJmaopxFmSiA1xztWnzJ/4RxMaNYYa3PDUGDhxJJ1R8ZeqG1w/cnHUkbUqpVfHFFU3Muv5b9otFKrVwH+WXkawV8+SVhfHjkVkLuTFF1+krKyMVatWcfr0aVpaWjhy5EivRoBCQ0N7lYRB/01NtPfFaBvr6zi59ioARj74hVRME6KHGuvrOPDvVwk89DpxptOW/RkuU3G45D7GXzqX4YMo6QgcMQHjdg06zU8XDaOi5cAlL9BcUwLFh/CoPkZYSzaeGgNRpjyiavOg9mvIAb6FWsWFM07DqfEcDYExeEYlMGxMot2W0E/751omH3icII2CUdGQNuFxWTLHBsh1TT2SiA1xvo3mi6FryBg0Wi2n9dHENmVQcSINBnEiptFoej1FcESAO2uuj+MPH2ViVBR0Gg1PXR/LiID++4OVn5/Po48+yrvvvoubmxvR0dHo9XoyMzOJi4sjJyeHefPmERsbS1paGrNmzSIlJYU1a9ZgMBjYsmUL0dHR5OTkcOONN/Lhhx8yb948EhISSEtLY8KECbz33nud3rfWX1MT7X0xWpPJyPjmgwDUm3p/n6EQQ01JfjYnP1/L2Px/kkQtcLb8fOBcQlMeJGHU4JxWHBQ2krQJj3dcWDrljnbtFJOJovxTFB/fR/2ZgziWZeFXd4IwYx4emgbGtWRBeRaUb4XDwL+hiACKXUZQ7zMGx9A4/EZMJGzUBJuo2NjS3ERddQWG6nIa6ippqq2g2VBJU0k2ySfXoj17udFpFCYfeJwfPfwJGj0Fv+BwmZ6pErmuqUcSsSGstaWZEGMhaCAgKhaAOp/xUJSBUpChbnA26qYpEcwYHUBOWT1R/q79XjXxgQceYPbs2cyZMwcABwcHxo0b1+4+scOHD/PBBx8watQoYmNjcXd3JzU1lVdeeYWXXnqJF154oV2fhw8f5t1332XcuHHMnDmTb7/9lunTp3c4d1+nJl5oIVpgSC5GK8RQ0Tb1rKWhDuOBD4mv3mEpP1+gCeT0qNsY98vfkewz+Nf+62ph6XNptNqzRUBGAT+9+dXc1Ej2if2Un8qgpSAT16ojBDWcIpgygikluKEUGlKhANgLzYqOU7pwKtxH0eofg0v4BIKjJxEYOhyNVtvjKYGNDQbqqiuorymnoaaCprpKWgyVtNZXozRUoTRWo22qRtdSh2NLDfrWOpyNtbiaDLgrBlw1TfgAPp11ft57fjqNwsTvfwffmx9X40al1o9aRz8anQNodQ1E4xGMo3coLr7D8PQPwzc4HFd3r95+K4SwSZKIDWGFuUcJ1xhpUJwIHDYCAIfwiVC0GZ/qLJWjs10hXi4DUrb+008/5euvv+bw4fbFU+Li4tolYmPGjGHMmDEAjBs3jlmzZlnadbY0w5gxY4iJiQFg4sSJ5OTkdJqI9dWFFqIFhtRitEIMJan/eI4pmX8i6JzpeGggyymOxsm/Jf6Kmwl1GFr/evRkYenOOOmdGT4+meHjk9vtr64oJf9YOrW5GVCShVfNccKas3HXNDDClMOImhyo+Q+cAr4xJzc1Gi+GmQrOVm+EQ/pYGp38cWytxbm1FmeTAVeTAQ/FgLOmhT7fIX5OomVQnDFoXKnXutOgc6dV40RsUwbnTsBQFCjR+OKj1OCkacULA14mAzSdhiagGijseJo6xYUKnS+1Dn406M0JGx5BOHiF4uwbiod/OD5B4Xh4+nR5j53cqyZswdD6ayjaKc89RDhQ4DCMkWcXwA4aMxV+gMiWbFqam2ximsNQdfXVV1NZWdlh/5tvvtnusV7/0/dIq9VaHmu1WozGjlMMzm2v0+k6bXMxerIQLQz+xWiFGGqKz5wkMfNPaM9JwkwKHLz8NeJn/krFyAYXL98AvKZeBVOvsuxTTCYKTh+n5MQ+Gs7sx6n8CP6GEwwz5uOlMeClGCxJklYD45szobmTzs9JkmpwxYAb9Tp3mnTuNDl40OrogdHJE8XZC42zJzoXbxzcvHF088HZwxcXDx/cPP1w9/LFzdEJt/O6T/vn2o5TNW94EMVkorqylMqSPGpL82mszKe1uhBNXRGO9SW4NJXh2VqOr6kCV00T7poG3E350Jxvfh21QDEdNChOVGh9qHHwp0HvT7NLIIp7ELrKUyRW/ttyr9qesY+Q9OtlaHW9v49biIshidgQ1lhoLhVe5RJp2TdseAx1igvumgZOHctgRGxyV4cLIYQQFqW5We1HwjD/0+/gJPf99DeNVkto1BhCo8YAN1v2NzYY2PvpeqYeWtXhmD3+N6ALm4yDqxdO7r44e/ji6umDq6cf7h7eeDo4nF3i13q6mqqp0Wrx8gvCyy8IxiV2ebxiMlFbW0Vl8WlqS/NpOJuwUVuMQ30xLo2luLeW42OqwJN6XDTNDFOKGdZSDC1AHVB6trNz7lWbevTPmFb9mVpcMGjcaNC606hzO5t8umN08sTk5InG2RONizcOrl44unrj5O6Di4cPrp6+uHn54uLi3usqlzIyN7RJIjaEaSvM9/G0eP/0i6/V6cjVj2J880HKjqdJIiaEEKJHAiJjMCrtqwS2Klr8I8eqGNXQ5uzixvBp12LM/FOH78vwa/+oyj/+fZ2qCeaEzcPLFw8vXxid0G3bBkMtFcVnqCk9TX15AS3VBSi1RbiVH2JCU3qH9loNeNCABw1gKgMT5uStoefxtSg66jSuGDRuNGrdaNR50OzgjtHp7Eii3hOcvdC5eOHg6kVT9h6Si96VKpJDmCRiQ5h7XQ4ADoGj2+2v9RkPxQdR8n9UISrRG1FRUezdu9fy+MMPP7R8PnXqVD799NMO7c5t/+yzzw5QpINLvSJTdoU4X5dVAuVdflUN1e+Li5sHw0aMY9iIce32F585ifHVyR2WFci+4TP0Lu401FbSVFdFq6GCFkuBkho0TdVom2txbKnFqbUWvdGAi6kON8WAu1KPTqPgqDHiQy0+Si0YMW/NQH03gZ4zMjfpwBMUJ89VJUGW65o6JBEbwgKb8wDwCo9pt99h2EQofg+v6sOdHSbEkObq7gVPlKgdhhA2qSdVAsXAk+/LT7pMTM8uxN0XismEoa4aQ00lDTXmsv3NdZW01FfTWl+F0lANTTXmapNnkzmP5iKGm/La9eOgMVGWe2TAEzG5rqlHErEhqra6An+qAAgeEdvuuYDRSbAPIppPYmxtRTfEKlwJIYTou4uZeib6j3xffmLtxFSj1eLm6YObpw8wokfHdDYyJ1N5h57Bs4S96JXCk+aF+0rxMc+1PkfYqAnUK3pcNU2cOb5fjfCEEEIIIfpNUNhIxl86R7XkNChsJOkTHsekmOcmmhR4P3ipJMtDjCRiQ1TNGfM6YSVOYR2e0zk4kOtk/kNQcix1QOMSwtY1NhjY//Qv2P/0L2hsMKgdjhBCCDuVdMOD1M40V7T80RTNa4bpmEwXXv7F2uS6ph5JxIaolpJjANS5D+/0+Wrv8QAY8zMGKiQh7ILJ2Ep8QxrxDWmYjK1qhyOEEMKOeY0wV6cO0VaSXWbg+5PlAx6DXNfUI4nYEKWvOgmA4jeq0+d1wxIA8Kw8NFAhCSGEEEIMLT7mtVyDNRU40Mpbe3LUjUcMKEnEhijv+lwAXELGdPq8/2jzOzSRzScwGY0DFpcQQgghxJDhHgQOzmgxEaop56usYgqre7F4mbBrkogNQSajkRBjAQB+EbGdtgmPjqdBccJN08iZs4U9hBBCCCGEFWk04B0BQEpIAyYF3k09rXJQYqBIIjYEFZ85gYummWZFR3Dk6E7bODg6cdrRXIK15FjaQIYnhBBCCDF0+EQBMDeyBYB3f8ijudWkYkBioEgiNgSV5Zjv+yrUheLg6NRluypv80LPrXn7BiQuIYQQQoghx9t8n9h4l0oCPPSU1jbx5aEilYMSA0ESsSGovvAoABXOEd2204YmAOBRmdXfIQlhUVVVRWJiIgkJCcTGxvLqq6+qHZIQQgjRf84W7NBVn+bmJPP/Zm/tyVUzIjFAHNQOQKig7DgAjV7dLxroO2oKHIDw5uMoJhMareTtov95eHiwc+dOXF1dMRgMxMbGcv311+Pn56d2aAC4unvB49Xmz1WORQghxCBwdkSMyhxuvjKcdTtOkJZdwdGiWsYEe/T76eW6ph75z3oIcq3NBsAhoPPS9W0ixk6mWXHAk3oKcg4PRGjCxpSXlxMYGEhOTs6AnVOn0+Hqar4UNDU1oSgKivLTApe/+c1veO655wYsHiGEEKJfnb1HjKpcQrxc+MW4IADellGxQU8SsSEooCkPAI9h47pt5+ikJ9fRvOBz0ZE9/R6XsD2rV69m3rx5REVFAbBz507mzp1LaGgoGo2GrVu3dnrcunXriIqKwtnZmeTkZNLSelfwpaqqivj4eMLCwnjkkUfw9/e3PLdixQpWr15NdXV1X1+WEEIIYTvOTk2kvhya6rh9mvnxR/vOUNckCywPZpKIDTENhlqCKQUgaETcBdtXeJkLdjTnZfRnWMIG1dfXs2HDBhYtWmTZZzAYiI+PZ926dV0e9/7777N06VIee+wx9u3bR3x8PCkpKZSUlFjatN3/df5WUGBeVsHb25v9+/eTnZ3NO++8Q3FxseXY2NhYRo4cydtvv90Pr/rCGhsM7Ht2LvuenUtjg0GVGIQQQgwizl7g7G3+vCqXS0b6MSLADUOzkS0/5vf76eW6ph5JxIaYglPmiolVuOMTEHLhA4LjAXCvkLXE1PKrX/2KgIAA/v73v1v2paam4uTkxLZt2/rtvJ9//jl6vZ6pU6da9s2ePZsnn3yS6667rsvjnn/+eRYvXszChQuJiYlh/fr1uLq68vrrr1vaZGRkkJmZ2WELDQ1t11dQUBDx8fHs2rWr3f65c+fy3nvvWemV9o7J2Mqkup1MqtuJySjvVAohhLCCtumJlTloNBpuSzaPir29O7fd9Pz+INc19UgiNsRU5ZkTsSKH8B61941OAiC8yVywQwy8v/71r9xwww2sWrUKgLq6Om677Tbuvfderrzyyn47765du5g8eXKvjmlubiY9PZ1Zs2ZZ9mm1WmbNmsXu3bt71EdxcTG1tbUAVFdXs3PnTsaMGdOuTVJSEmlpaTQ1NfUqPiGEEMImtU1PrDTfF3bD5DBcHHUcLa7lh5xKFQMT/UkSsSGmufgYALXuUT1qby7YocObOgpPH+/HyNRR39za5dbYYrRq274KCQnhwQcfJD8/n/Lych544AH0ej1PP/10n/vsidzc3A4jVBdSVlaG0WgkKCio3f6goCCKinq2Jkpubi7Tp08nPj6e6dOnc//99xMX134abWhoKM3NzT3uU4ihJi8vj8svv5yYmBgmTJjAP/7xD7VDEkJ0p61yYpU5EfNyceTaieZrsJSyH7ykfP0Q41h5AoBWn+5L17fRO7tywiGKUcaTFB/dQ2jUmAsfZEdiVn7Z5XMzxwSwcWGS5fHkP/2HhvMSrjbJw315/7fTLI9/9vQOKgzN7drk/N+cPsc5evRoXF1dWblyJZs3byYtLQ1nZ+c+99cTDQ0N/X6OziQlJZGRkdFtGxcXF8B8H5sQoiMHBwfWrl1LQkICRUVFTJ48mV/+8pe4ubmpHZoQojM+P5Wwb3Pb1EjeTcvji8xCSmrHEegx8Ndk0b9kRGyI8ao3v6uiDx7b42MqPM1tG0/v65eYxIVptVri4uJ4+eWXefLJJ4mPj+/3c/r7+1NZ2bvpEP7+/uh0unbFNcA83TA4ONhqsVVUVAAQEBBgtT6FGExCQkJISEgAIDg4GH9/f8vvjRDCBlnuEftp9Gt8qBeTIrxpMSp88EOeOnGJfiUjYkOIYjIR3HIGNOAXEdPz40ISoPIz3MoP9V9wKslaldLlc1qNpt3j9EdnddGyY9tv/3fmxQV2nrYbdSdNmsRDDz1k2Z+Tk8O8efOIjY0lLS2NWbNmkZKSwpo1azAYDGzZsoXo6GgArr76agoLC2lqamL58uXceuut7N69m9///vd8//33lJeX87Of/Yxdu3YRHBzMxIkTe12Z0MnJicmTJ7N9+3auvfZaAEwmE9u3b2fJkiXW+WIAmZmZhIWFtStrL4Q92blzJ8888wzp6ekUFhayZcsWy+9Mm3Xr1vHMM89QVFREfHw8L774IklJSZ132I309HSMRiPh4T27N1gIoQLvKPPHqlxQFDj7f8Xt0yLZd7qKd1JPc89lI3HQyRjKYCKJ2BBSXnIGf00DRkVD8PDu1xA7l/eIRMiCsMajKCYTGu3g+SPg6tTzX4H+atsTa9euJTU1lYSEBLTnff0PHz7MBx98wKhRo4iNjcXd3Z3U1FReeeUVXnrpJV544QUA3nzzTXx9fTEYDEyZMoUbb7yRadOmMWPGDJ5++ml+/PFHVq5caRm5SklJYfny5VRWVuLj4wOYC4WcOHHCcu7s7GwyMjLw9fUlIiICgKVLlzJ//nwSExNJSkpi7dq1GAwGFi5caLWvx65du/q1UIkQ/a1tKYg777yT66+/vsPzbctArF+/nuTkZNauXUtKSgpHjx4lMDAQMC8D0dra8f7Tbdu2We7vrKio4I477uDVV1/t3xckhLg43uGABlrqwVAG7uYZH7NjQ/jTp4cpqG7k6yMlXDneerNLhA1QxEWrrq5WAKW6ulrtULqV+d1nivKYp3Lm8eheHddgqFVaVnorymOeSlHeiX6Krv80NDQoWVlZSkNDg9qh9MmBAwcUvV6v3HfffYqTk5PS0tJieS47O1uJjY21PL7uuuuUL774QlEURfnuu++Ua665xvLcihUrlAkTJigTJkxQ3NzclGPHjimKYv76jBkzRpkzZ06HcyclJSnr16+3PN6xY4cCdNjmz5/f7rgXX3xRiYiIUJycnJSkpCRlz549VvlatMXr5eWl7N69u8ftrfn9NxmNiqG2SjHUVikmo9EqfQ519vI3tL8AypYtW9rtS0pKUn73u99ZHhuNRiU0NFRZs2ZNj/ttbGxUpk+frrz55ps9altdXW3Z8vLyhvT3RAhVPDdOUR7zVJTTae12r/n8sBL5v58qt71mvWvpueS6Zn09va4NnqENcUF1+YcBKNNH9Oo4Z1d38nTmYwqyelaCXFhHY2Mjt9xyCzfddBNPPvkkzc3NHDlypF0bvV5v+Vyr1Voea7VajEZzcZEdO3bw3XffkZqayv79+xk7dqyl9HtJSQnNzc2WiofnWrlyJS+88AKms0sXXH755SiK0mHbtGlTu+OWLFlCbm4uTU1NpKamkpycbLWvycaNG0lKSmq3vtlA0mi1uLp74eruNahGh4XtsMYyEIqisGDBAn7+859z++23X7D9mjVr8PLysmwyjVEIFZxXObHNrckRaDSw63gZp0rrrH5aua6pR77aQ4hSZi4/3+A5otfHlnmapzI25v1o1ZhE95YtW4bBYOCll17Cx8eHyMhI1q5dS0FBQa/6qampwc/PD2dnZzIyMti/f7/lucWLF/Piiy8yZcoUnnvuuXbHzZkzh7vvvpv8/HyrvB5rcHR05MUXX1Q7DCH6jTWWgfjuu+94//332bp1KwkJCSQkJHDw4MEu2y9fvpzq6mrLlpcnhQGEGHCdVE4ECPd1ZeYY85TkzamnBzgo0Z/kHrEhxKXmFAAa/+heH2sMmgBV/8a1rOsLubCubdu2sW7dOr755hs8PDwAWLFiBcuWLaO8vJwtW7b0uK+rrrqKv/3tb8TExDB+/HjLQs0bNmwgMDCQOXPmcPnll5OUlMS8efPaLaD84IMPWvV1Xay77rpL1fM3NdZz4G/m+90m3LsRvbOrqvEI0Zmf/exnlpHsntDr9e1G14UQKvDuPBEDuH1qJF8fKeEfe/N4+MoxuDjprHZaua6pRxKxIcSv0fwuituwnpeub+M9cgochdCGY9YOS3ThyiuvpKWlpd2+u+66q10iEhUVxd69ey2PP/zwQ8vnU6dO5dNPPwXM/2R98cUXHc4RGxvLokWLAHBzc+PQocFXGdPajK0tTKk2fy3rW1su0FqI3huoZSCEEDamrYR9VccFnGeMDiDc14W8igb+tb+AX0+x3vRhua6pR6YmDhHNTY0Em8wX9aDhcb0+PiImCaOiIYBKygpkhXchhOgv5y4D0aZtGYhp06Z1c6QQwq5ZpiZ2/D9Lp9Vwa7L5+Tf35FiWtRH2TRKxIaIwOwsHjQmD4ox/cO+KdQC4unuRpwsDIP+IFOwQQoiLUVdXR0ZGBhkZGcBPS0GcPm2eubB06VJeffVV3njjDQ4fPsy9995r9WUghBA2pm1qYvUZMHZcmuLXieE4OWjJzK9h/5nqAQ5O9AdJxIaIitNZABQ4hPW5Ik6Zu3lKY33OPqvFJYQQQ9HevXuZOHEiEydOBMyJ18SJE1m5ciUAN910E88++ywrV64kISGBjIwMvvjiiw4FPIQQg4hHCOicQDFCzZkOT/u6OXF1XAgAb+2W2UmDgSRiQ0RT0VEAqt2i+txHa3A8AM5SsEMIIS5KT5aC6M9lIIQQNkirBe+zs5Y6mZ4IcNs086jZvw4UUGloHqjIRD+RRGyI0FacAKDFu/el69t4Dk8EILT+qFViEkIIIYQQ5+hiLbE2E8O9iR3mSXOriX+kyzIT9k4SsSHCw5ADgGPQ6D73ETHevIBuEOWUF3ccMhdCCCGEEBehm4IdABqNhtunmtu8vec0JpMU7bBnkogNEcEt5sTJOyymz324e/qQpwkFID9rj1XiEsLeuLh6UHFfFhX3ZeHi6qF2OEIIIQaTthL2nawl1uaa+GF4ODtwuqKencdLL/qUcl1TjyRiQ0B1eTE+1AAQOjL2ovoqdh8HQH2uFOwQQ5NGq8U3cBi+gcP6XPhGCCGE6NQFpiYCuDjp+NVk8zpib++5+KIdcl1Tj3y1h4DCU+biGsX44erudVF9tQaZ1yBzKj1w0XEJIYQQQohzXGBqYptbp5qLemw/UkJeRX1/RyX6iSRiQ0DNmcMAlOovfhV297MFO4KlYIcYopoa60l9aSGpLy2kqVEufkIIIayobUTMUALNhi6bjQxw52ej/FEUeCft9EWdUq5r6pFEbAgwlh4DwODR94qJbcJjpgEQqpRQVVZ00f0JYW+MrS0kl31EctlHGFtb1A5HCCHEYOLiA/qzs5equk+wbjtbtOP9H/JoajX2+ZRyXVOPJGJDgHP1KQAUv1EX3ZeXjz9nNMEA5GWlXnR/QgghhBDiLI0GfLpfS6zNrHGBBHs6U2Fo5t8H5c1xeySJ2BDg02D+RXYNGWuV/krcxgBQl7PXKv0J0RfZ2dnMnDmTmJgY4uLiMBi6nsIhhBBC2I0eFOwAcNBpuSXZnLS9ZYWiHWLgSSI2yBlbWwk1FgLgH3VxFRPbNAXGA+BUIgU7hHoWLFjAqlWryMrK4ptvvkGv16sdkhBCCHHxelDCvs1vpoTjoNWQnlvJoYLqfg1LWJ8kYoNc0enjOGlaaVIcCQobaZU+3aMmARBkOGKV/sSFLVu2DL1ezy233KJ2KDbh0KFDODo6Mn36dAB8fX1xcHBQOSohhBDCCiyJ2IVHuQI9nUmJNd8y8vaeiyvaIQaeJGKDXFluJgAFulB0VvpHta1gR5hSRHVlmVX6FN1bvnw5zz33HO+++y4nTpxQO5xu7dy5k7lz5xIaGopGo2Hr1q2dtlu3bh1RUVE4OzuTnJxMWlpaj89x/Phx3N3dmTt3LpMmTeKpp56yUvRCCCGEyno4NbHN7WeLdmz9MZ+aRim2YU8kERvkGgrNo1aVLpFW69PbP5hCAgDIy9pttX5F17y8vFi0aBFarZaDBw+qHU63DAYD8fHxrFu3rss277//PkuXLuWxxx5j3759xMfHk5KSQklJiaVNQkICsbGxHbaCggJaW1vZtWsXL7/8Mrt37+arr77iq6++GoiXJ4QQQvQvy1piOaAoF2yePNyX6EB3GlqMfJR+pn9jE1ZlF4nYf//7XzQaTafbDz/8AMDjjz/e6fNubm5d9rt//35uvvlmwsPDcXFxYdy4cbzwwgsD9bIGhKbcPHrS5H3xpevPVehmLvxRl51u1X7tQnU+ZO80fxxAra2tuLq6kpmZOaDn7a3Zs2fz5JNPct1113XZ5vnnn2fx4sUsXLiQmJgY1q9fj6urK6+//rqlTUZGBpmZmR220NBQhg0bRmJiIuHh4ej1en75y1+SkZExAK8OnF3cKViQRsGCNJxd3AfknEIIIYYQ77NVE5vroL7igs01Gg23TzMnb2/tyUXpQfJ2Lrmuqccubqq45JJLKCwsbLfv0UcfZfv27SQmmhcYfvjhh7nnnnvatbniiiuYMmVKl/2mp6cTGBjI22+/TXh4ON9//z133303Op2OJUuWWP+FqMC9NhsAh4DRVu23KSAWDLtwKLbTgh2KAi19WLQw4x349/+AYgKNFmb/GRJ6cd+Wo6u5NG0frFixgrq6ugFLxJ566qkLTvnLysoiIiKiV/02NzeTnp7O8uXLLfu0Wi2zZs1i9+6ejbBOmTKFkpISKisr8fLyYufOnfz2t7/tVRx9pdXpCI0aMyDnEkIIMQQ5uoB7MNQVQVUOuPld8JDrJg7j6X8f4WSpgd2nyrlkpH+PTyfXNfXYRSLm5OREcHCw5XFLSwsff/wx999/P5qz/9S6u7vj7v5TFr9//36ysrJYv359l/3eeeed7R6PGDGC3bt389FHHw2aRCygOQ8Az7BxVu3XLTIRciDQXgt2tNTDU6EX14digs8fNm899YcCcOp6lLYr6enprF+/njlz5gxYInbPPffw61//uts2oaG9/xqWlZVhNBoJCgpqtz8oKIgjR3r28+Tg4MBTTz3FjBkzUBSFK6+8kquvvrrXsQghhBA2ySfSnIhV5sKwyRds7uHsyHWThvH2ntO8vSe3V4mYUI9dJGLn++STTygvL2fhwoVdtnnttdcYPXq0papaT1VXV+Pr69ttm6amJpqamiyPa2pqenWOgVJXU0kg5iHt4JETrNr3sJip8A2EGQuoq6nE3dPHqv2Ln5hMJn7729+yZMkSkpOTue2222hpacHR0bHHfRQUFPDII4+wefPmHh/j6+t7wd8FNc2ePZvZs2cP+HmbmxrZt3EpAJMWPo+T3nnAYxBCCDHI+URBXmqPSti3uW1qJG/vOc2Xh4oprmkkyLNn1ye5rqnHLhOxDRs2kJKSQlhYWKfPNzY2snnzZpYtW9arfr///nvef/99Pvvss27brVmzhieeeKJXfauh8FQm0UA5Xvj5WPedEb+gMIrxI0hTzumsVGKmXmXV/vudo6t5dKo3agpgXZJ5JKyNRge/SwXPHo4MObr27pzAiy++SFlZGatWreL06dO0tLRw5MgR4uLietxHaGhor5Iw6L+pif7+/uh0OoqLi9vtLy4ubjfybataW5qYWmT+Wta3rJELlhBCCOvrZeVEgLHBniRF+ZKWU8G7aad5cFbPbkuR65p6VC3WsWzZsi6LcLRt509VOnPmDF9++SWLFi3qst8tW7ZQW1vL/PnzexxLZmYm8+bN47HHHuPKK6/stu3y5cuprq62bHl5eT0+z0CqzssCoNgxvF/6L3A1zyeuOfVDv/TfrzQa8xTB3mz+0TD3BXPyBeaPc9ea9/e0j17eH5afn8+jjz7KunXrcHNzIzo6Gr1eb5memJOTQ3x8PLfeeivR0dHce++9bN26leTkZGJjYzl+/LilXWJioqX9/PnzGTduHDfddFOXN/Xec889ZGRkdLv1ZWqik5MTkydPZvv27ZZ9JpOJ7du3M23atF73J4QQQgw6lsqJPU/EAG47W7Tj3bTTtBhNF2gt1KbqiNhDDz3EggULum0zYkT7an8bN27Ez8+Pa665pstjXnvtNa6++uoO96B0JSsriyuuuIK7776bFStWXLC9Xq9Hr9f3qG81tZQcA6DO3Xql68/V6B8Hp79HZ68FO/pi0h0w8gqoOAW+I8BrWL+e7oEHHmD27NnMmTMHMN8bNW7cuHb3iR0+fJgPPviAUaNGERsbi7u7O6mpqbzyyiu89NJLHSqBHj58mHfffZdx48Yxc+ZMvv32206n8PZ1amJdXV27tc6ys7PJyMjA19fXMnq2dOlS5s+fT2JiIklJSaxduxaDwdDtdGMhhBBiyOjDiBjAVeOD8Xd3orimia+yivllXEg/BCesRdVELCAggICAgB63VxSFjRs3cscdd3R5f0x2djY7duzgk08+6VGfhw4d4uc//znz589n9erVPY7FHjhVnQLA5DuqX/p3iZwEpyGg9nC/9G+zvIb1ewIG8Omnn/L1119z+HD7r29cXFy7RGzMmDGMGWMenRw3bhyzZs2ytPv888879DtmzBhiYmIAmDhxIjk5Ob2+l7I7e/fuZebMmZbHS5ea553Pnz+fTZs2AXDTTTdRWlrKypUrKSoqIiEhgS+++KLHb54IIYQQg5pPlPljVR6YjKDV9egwJwctv5kSwUs7TvDW7lxJxGycXd0j9vXXX5Odnc1dd93VZZvXX3+dkJCQTm/i37JlC8uXL7dMd8zMzOTnP/85KSkpLF26lKKiIgB0Ol2vEkRb5VVvfhfFOXhsv/QfNm4a7IJw4xnq66pxdffql/MMVVdffTWVlZUd9r/55pvtHp87OqvVai2PtVotRqOxw/HnttfpdJ22uRiXX355j9YwWbJkyaCpTiqEEEJYlWcoaB3B1GK+R92757eZ3Jwcwcv/PcHuU+WcKKllVKBHPwYqLoZdLOjcZsOGDVxyySWMHdt5YmEymdi0aRMLFixAp+v4zkF1dTVHjx61PP7www8pLS3l7bffJiQkxLJ1t/aYvVBMJkJbzaur+0bG9Ms5/EMjKcMbnUbhdFZav5xDCCGEEGLI0erA62xRul5OTxzm7cIV48wzTN7ec9rakQkrsqtE7J133uG7777r8nmtVkteXl6XUwwXLFjQ7p36xx9/HEVROmw5OTnWDn3AlRRk46ppokXRERJl3TXEzpXvYp4SV31qb7+dQwghhBBiyLEU7Mjp9aG3TzUf+8/0MxiaWq0YlLAmu5qaKHquNDuTIKBIG0S4U/8VFmnwi4UzqWiL9vfbOUTXoqKi2Lv3pyT4ww8/tHw+depUPv300w7tzm3/7LPPDlCkg4ezizs5N5krPka4uF+gtRBCCNFHbfeJ9bJyIsDPRvkT5edKTnk9H2cUcEty10vNyHVNPXY1IiZ6zlBgvg+u3KV/Kia20UdMAsCvZogV7BBDllanI2pcIlHjEtF2MgVaCCGEsIo+Vk4E0Go13HZ2VOzN3Tnd3rst1zX1SCI2SCll5vWjGj1HXKDlxQkZNxWACONpGuvr+vVcQgghhBBDRh/XEmtz4+Qw9A5ajhTVsu90x+JfQn2SiA1SrrXZAGgDovv1PEHDRlCBJw4aE6ePyH1iYvBrbmpk94aH2b3hYZqbGtUORwghxGBlmZqY06fDvV2duCY+FIC3dnedzMl1TT2SiA1S/k3mKjnuof1Tur6NRqvljPNoACpPSOVEMfi1tjQxLe9VpuW9SmtLk9rhCNGl+vp6IiMjefjhh9UORQjRF95R5o91RdDS0Kcubp9mHlX7/GARZXWdX7PkuqYeScQGocb6OoJNpQAEDo/t9/MZ/Mzn0BRKwQ4hhLAVq1evZurUqWqHIYToK1dfcDpbPKMqr09dTAjzJj7Mi2ajiQ/29q0P0X8kERuECnMOo9Uo1OCKX+Cwfj+fPnwiAL5SsEMIIWzC8ePHOXLkCLNnz1Y7FCFEX2k0PxXs6OP0RIDbp0UBsHnPaYymrot2iIEnidggVHn6EABFDmFotP3/LQ4eOw2AiNYcmhrr+/18Qghhz3bu3MncuXMJDQ1Fo9GwdevWDm3WrVtHVFQUzs7OJCcnk5bWu6nfDz/8MGvWrLFSxEII1bTdJ9aHyoltrp4QgrerI/lVDfz3aIl14hJWIYnYINRcdAyAareoATlfSEQ01bjhpDFy+kj6gJxTCCHslcFgID4+nnXr1nX6/Pvvv8/SpUt57LHH2LdvH/Hx8aSkpFBS8tM/UAkJCcTGxnbYCgoK+Pjjjxk9ejSjR48eqJckhOgvF7GocxtnRx2/TgwH4K09fU/ohPXJgs6DkK7yBACtPiMH5HwarZbT+tHENf1I5YkfIGH6gJxXCCHs0ezZs7udMvj888+zePFiFi5cCMD69ev57LPPeP3111m2bBkAGRkZXR6/Z88e3nvvPf7xj39QV1dHS0sLnp6erFy5sstjmpqaaGr66Sb9mpqaXr4qIUS/uIi1xM51a3IEf995im+OlZJbbiDSz80KwYmLJSNig5CnIQcAfdCYATtnne94AJTCjAE7pxBCDDbNzc2kp6cza9Ysyz6tVsusWbPYvXt3j/pYs2YNeXl55OTk8Oyzz7J48eJuk7C2Y7y8vCxbeHj4Rb0OIYSVXGQJ+zaRfm5cNjoARYHNqacvOixhHZKIDTKKyURI6xkAfCJiBuy8TuGTzOesloIdYnDTO7tx7JpPOHbNJ+id5R1FYV1lZWUYjUaCgoLa7Q8KCqKoqKjfzrt8+XKqq6stW16eVFcTwiZYpiZefPJ0+1RzXx/szaOxxWjZL9c19cjUxEGmorQAPwyYFA0hw8cP2HmDRidDGkS2ZNPS3ISjk37Azi0Gn+zsbO68806Ki4vR6XTs2bMHNzfbuDjoHBwYPekytcMQokcWLFjQo3Z6vR69Xv5uC2FzvCPMH5uqoaESXHz63NXMsYEM83Yhv6qBTw8UcuPkMECua2qSEbFBpjg7E4AibQDOru4Ddt5hI2KowRW9poXTR38csPOKwWnBggWsWrWKrKwsvvnmG/kHUQwZ/v7+6HQ6iouL2+0vLi4mODhYpaiEEKpxcgO3APPnlRd3n5hOq+GWZHNiJ0U7bIMkYoNMXb55amCZfmDn92u0WvKcRgFQcTx1QM8t+k95eTmBgYHk5OQM2DkPHTqEo6Mj06ebi774+vri4PDT4P1vfvMbnnvuuQGL53zNTY3seWsle95aSXNTo2pxiMHJycmJyZMns337dss+k8nE9u3bmTZtmoqRCSFUY6X7xABumhKOo07D/rwqDpypAuS6piZJxAYZU+lxABo8hg/4uWt9zFMhTQUZA35u0T9Wr17NvHnziIqKAnq2/hFc3BpIx48fx93dnblz5zJp0iSeeuqpds+vWLGC1atXU11d3deXdVFaW5qYevIFpp58gdaWpgsfIMR56urqyMjIsFQ+zM7OJiMjg9OnzfeALF26lFdffZU33niDw4cPc++992IwGCxVFIUQQ4yVKicC+Lvr+WVcCABvnx0Vk+uaeiQRG2T0NdnmT/yjB/zcDmETAfCuyhrwcwvrq6+vZ8OGDSxatMiy70LrH8HFr4HU2trKrl27ePnll9m9ezdfffUVX331leXY2NhYRo4cydtvv90/L1yIfrZ3714mTpzIxInmv5lLly5l4sSJlsqGN910E88++ywrV64kISGBjIwMvvjiiw4FPIQQQ4SlYId1phO2Fe34OKOA6voWq/Qp+kYSsUHGr9H8S+oaMm7Azx04JhmAiJZTtLY0D/j5B6tf/epXBAQE8Pe//92yLzU1FScnJ7Zt29Zv5/3888/R6/VMnTrVsm/27Nk8+eSTXHfddV0ed+4aSDExMaxfvx5XV1def/11S5uMjAwyMzM7bKGhoQwbNozExETCw8PR6/X88pe/7LBm0ty5c3nvvfes/pqFGAiXX345iqJ02DZt2mRps2TJEnJzc2lqaiI1NZXk5GT1AhZCqMuKUxMBJkf6MDbYg6ZWE/9IlwqpapJEbBBpaW4ixGgubxwwgBUT24SNjMOgOOOiaSbv+P4BP3+fNBu63loae9G24cJt++ivf/0rN9xwA6tWrQLM05puu+027r33Xq688so+93shu3btYvLkyb06xhprIE2ZMoWSkhIqKysxmUzs3LmTcePav7GQlJREWlpauwVohRBCiEHJilMTATQaDbdPM/e5OfU0JpNilX5F70n5+kGkKPcI4Roj9YqewNCBv0dMq9OR6zSKmJZMyo6lMTxmyoDH0GtPhXb9XPSVcOs/fnr8zChoqe+8beTPYOFnPz1eGwf15e3bPN63e5pCQkJ48MEHeeWVVygvL+eRRx5Br9fz9NNP96m/nsrNzSU0tJuvTye6WwPpyJEjPerDwcGBp556ihkzZqAoCldeeSVXX311uzahoaE0NzdTVFREZGRkr2IUQggh7Erb1MSq02Aygfbix1GuTRjGms+PkF1mIDWngisuukfRF5KIDSLluVmEA4UOwxip06kSQ41PDJRkYsyXEvbWNHr0aFxdXVm5ciWbN28mLS0NZ2fnfj1nQ0NDv5+jK7Nnz2b27NldPu/i4gKY72MTQgghBjXPMNDowNgMdUXg2bs3STvjpnfghknDeGN3Lv/Ye0YSMZVIIjaINBaZRxyqXNUbIdANmwglH+BlLwU7/lDQ9XOa85LZR0500/a8d6cePNj3mDqh1WqJi4vj5Zdf5s9//jPx8fFW7b8z/v7+VFZW9vqYgVgDqaKiAoCAgACr9SmEEELYJJ0DeIWZpyZW5lglEQO4fVokb+zOZeexUlDnfdchT+4RG0S05eZEodl7pGoxBIxOAiCy+QTG1lbV4ugxJ7euN0fnXrR1uXDbi6Ao5vnbkyZN4qGHHrLsz8nJIT4+nltvvZXo6Gjuvfdetm7dSnJyMrGxsRw/ftzS9uqrr2by5MnExsayefNmAHbv3k1SUhKtra0UFxcTHR1NUZH5PsOJEyeSldW7hHqg1kDKzMwkLCwMf39/q/XZU3pnNw794h0O/eId9M4X930VQgghesTKlRMBRgV6MG2EH4048VL4X+S6pgIZERtE3OtyAHAMGPjS9W3CoxNoUJxw1TSRezKTyDEJqsUymKxdu5bU1FQSEhLQnjc3/PDhw3zwwQeMGjWK2NhY3N3dSU1N5ZVXXuGll17ihRdeAODNN9/E19cXg8HAlClTuPHGG5k2bRozZszg6aef5scff2TlypWWkauUlBSWL19OZWUlPj4+gLlQyIkTP40Mtq1/5OvrS0REBGAuxT1//nwSExNJSkpi7dq1Vl8DadeuXf1aqKQ7OgcHxl86R5VzCyGEGKKsXLCjze3TItl9qpxNheHcPf8KdA4yRjOQ5Ks9iAS1mEuQeoXHqBaDzsGBXEfziFzp0T2qxTGYHDx4kOXLl3PfffeRlZVF63kjjWPGjGHMmDHodDrGjRtnqVgYFxdHTk6Opd1f/vIX4uPjueSSSzh9+rRl8dgnn3ySt956i8bGRm6//XZL+7i4OCZNmsQHH3xg2Xeh9Y+g/9dAamxsZOvWrSxevNgq/QkhhBA2zzIilmPVbn8RE0Sgh56yumb++vVxCqsbLnxQPyqsbuD7k2VDJg4ZERskqivL8MNclS94RKy6sXjHQNlhWvMzVI1jMGhsbOSWW27hpptu4sknn+Tll1/myJEjxMb+9D3W6/WWz7VareWxVqvFaDQCsGPHDr777jtSU1NxdnYmMTHRUvq9pKSE5uZmS8VD3TmFXlauXMkjjzzC4sWL0Wq1lvWPLmTJkiUsWbLEKl+D823cuJGkpKR265sNpJbmJvZt+QsAk677fzg66S9whBBCCHGRfM5Ww7bi1EQAR52WCaGuhJz4F9XfbGPG1z9n1fUT+XViuFXP0xMf7M3jj1sOYlJAq4HV18XZRBxrro/jpikR/XIuScQGieLsTLyAUnwI8PJVNRbNsAQo+ycelZmqxjEYLFu2DIPBwEsvvYSHhweRkZGsXbuWVatW9aq0fE1NDX5+fjg7O5ORkcH+/T+t87Z48WJefPFFvvjiC5577jn+53/+x/LcnDlzOH78OPn5+YSHD/wfw844Ojry4osvqnb+luZGkg+vAaB+zr2SiAkhhOh//TQ1sbC6ge+PFpLlvAmAD40zWP7RQZZ/ZN2iY71lUrCZOP7wUSYzRgcQ4uVy4QN6SRKxQaI6z1xUocQpHLXryPlHJ8N+iGg6gcloRKtSKX17t23bNtatW8c333yDh4cHACtWrGDZsmWUl5ezZcuWHvd11VVX8be//Y2YmBjGjx9vWah5w4YNBAYGMmfOHC6//HKSkpKYN28eY8aMsRz74IMPWvV1Xay77rpL7RCEEEKIgdU2NbGmAFqbwME6bwJmlxmQ5Zy7Z1QUcsrqJRETXWstOQZAncfAL+R8vvDRCTQpjnhoGsjLziJ8VJzaIdmlK6+8kpaWlnb77rrrrnaJSFRUFHv37rU8/vDDDy2fT506lU8//RQwT1/84osvOpwjNjaWRYsWAeDm5sahQ4es+hqEEEIIYQVuAeDoCi31UJUH/qOs0u1wfzc05+3TauDfv59OkOfA1bQvrmlk9gu7MJ2TFdpKHDqNhih/1345nyRig4S++iQAiq91fjEvhqOTnmOOwxndeoySo6mSiAkhhBBCXAyNxjw9sfQwVOVYLREL8XLh0Tnj4OyqM1rM90SNCfa0Sv895e3qxJrr4/jDR5kYFQWdRsNT18faTBz9MRoGkogNGj715gp4LiFjVY7ErNIrBsqP0ZK3T+1QhBBCCCHsn8/ZRMzKBTvmTRxmScQ+fWA6w0MDrdp/T900JYIZowPIKasnyt+135IfW4pDErFBwGQ0EmLMBw34R41XOxwANKEJUL4V90qZ6iaEEEIIcdH6qWDHuYI81S1AFeLloloCpkYcso7YIFCUdwJnTQvNio7giDEXPmAA+I6aAkB403EUk0nlaIQQQggh7JxPlPmjldcSE+qREbFBoCwnk1CgUBdKpINtfEsjxibSrOjw0hgoyD1G6HDbmDIpxMVy0ruwf8YrAIzXq/+unRBCiCHCsqizdUfE5LqmHtv4r11clPrCIwBUOEcQqXIsbZz0zpxwiGKU8SRFR3ZLIiYGDQdHJ+J//hu1wxBCCDHU9NPURLmuqUemJg4CmvITADR6jVQ5kvYqvGIAaMr7UeVIhBBCCCHsXNuIWEMlNFarG4uwChkRGwRca7MB0AVGqxxJe0pwPFT8C7eKTLVDEcJqWpqb+PGzvwMwcc7dODqpe2Oz6L3hw4ej0Zy/cs6FPfjggzzwwAP9EJEQQvSA3gNc/aC+3Dw9MWSCVbqV65p6JBEbBAKa8gDwHDZO5Uja8xmVBFkQ3mgu2KHRygCssH8tzY0k7V8BQP0v7pALlh3atGlTn46LioqyahxCCNFr3pHmRKzKmomYXNfUIomYnauvqyaYMgCCR9jWwskR4xJp+ViHj6aGojMnCY6wrRE7IcTQdNlll6kdghBC9I1PJBTss3rBDqEOGaKwc4WnzOt0VeKBt3+wytG05+zixmmHCAAKj6SqHI0QQgghhJ2TEvaDiiRidq4qLwuAYsdwlSPpXLmHebpk4+l0lSOxb5dddhkajabDdscdd6gdmhCDQkBAAIGBgZ1u4eHhzJgxgx07dqgdphBiqBuARZ3FwJGpiXauufgYADVuUeoG0gUlJB6qPse1XAp29JWiKPz44488++yz3Hrrre2ec3d3VykqIQaX0tLSLp8zGo1kZmZy2223cfDgwQGMSgghztNPa4kJdUgiZuccq04CYPQZoXIknfMakQiHYVjDMSnY0UfHjx+ntraWGTNmEBxsW9NPhRgsSktLKS0tJSYmpt3+rKwsAgICiI+P56GHHlIpOiGEOOvcETFFgT5UgBW2Q/4rtnNehhwA9MG2uWByZEwyRkWDP1WUFZ1WO5wODAZDl1tjY2OP2zY0NFywbV+lp6fj4ODAhAnWqY4khOhoyZIlVFZWdthfWVlpKVm/YMGCAY5KCCHO4xUOGi20NkJdsdrRiIskiZgdU0wmQlvPAOAXEXOB1upwcfMgT2e+fy0/a7fK0XTk7u7e5XbDDTe0axsYGNhl29mzZ7drGxUV1aFNX+3btw+j0Yifn1+7/n77298C4O/v3+GYnJwcEhMT2+1bsGABn376KQBnzpzh+uuvZ+TIkSQmJvKrX/2K4uLiLvsTP3HSu5CetJb0pLU46V3UDkdYSXZ2NpdeemmH/ZdeeimZmTK1WghhIxycwHOY+XMrTU+U65p6ZGqiHSsrOk2AphGjoiF4uG2tIXauUo9xRFWfpuH0PuBmtcOxO/v27ePmm2/miSeeaLff19e3T/0pisK8efO47777+OijjwDYtWsXpaWlBAUFXXS8g52DoxOTf7lQ7TCElXU2Gtbm/BFvIYRQlXckVOeZpydGJF90d3JdU48kYnasJPsQAUChNogwZ1e1w+mSMTgeqr/Epcz2bnKvq6vr8jmdTtfucUlJSZdttefd+5aTk3NRcZ1r3759rF69mlGjRlmlv+3bt+Pu7s6iRYss+6ZPn26VvoWwVxMmTGDTpk0dph+++eabxMXZ1hqNQoghzicKcr+VEvaDgCRidqyu4DAA5c4RhKkcS3e8RiTCUQitP6p2KB24ubmp3rY7p06doqqqivj4eKv0B+biA5MmTbJaf0NNa0sz+7/aDED8L27FwdFJ5YiENfz1r39l3rx5vPHGG5bfj3379lFbW8vWrVvVDa6PsrOzufPOOykuLkan07Fnzx6r/W0SQqjIypUT5bqmHknE7JhSdhyABk/brJjYJiImGdPnGgI1FZQV5eEfbJtrntmi9HTz+mtBQUEUFRW1ey4wMLDDSFwbTRdVlLraL3quuamByWkPAlA/43q5YA0Sw4YNY+/evWzfvp2sLPP6jLNnz2bWrFkqR9Z3CxYs4Mknn2T69OlUVFSg1+vVDkkIYQ1WXktMrmvqkUTMjrnUnAJA4x+tciTdc/PwJlc3jEjTGfIP75FErBf27dsHQHR0+++xXq+npqYGJ6fO/1j6+fl1uOeloqICf39/nJycLPeGCSHMPv/8c8vnI0eORKPR4OXlRX19Pa6utjv1uyuHDh3C0dHRMu24r/eUCiFskKwlNmhI1UQ75tdoLgfvHmq7hTralLqby+vX5+xVORL7smbNGhRF6bA1NjZ2mYSBuRqkt7c333//PWCuknjw4EHGjx/PrFmzqKmpYdOmTZb23377rVSGE0PaP/7xj3bbBx98wJNPPklcXBzbt2+3+vl27tzJ3LlzCQ0NRaPRdDr9cd26dURFReHs7ExycjJpaWk97v/48eO4u7szd+5cJk2axFNPPWXF6IUQqvKJMn+sOQPGFlVDERdHRsTsVFNjPSGmYtBA0PBYtcO5oNagCVDzH5zL5J99a6usrCQs7Ke7BJ955hluvvlm3njjDe677z5qampwcHDglVdesZTR37p1Kw888AB/+tOfcHZ2JjY2lr/+9a+0trbK9CUxJG3cuLHT/W1LPfQmCeoJg8FAfHw8d955J9dff32H599//32WLl3K+vXrSU5OZu3ataSkpHD06FECAwMBSEhIoLW1tcOx27Zto7W1lV27dpGRkUFgYCBXXXUVU6ZM4Re/+IVVX4cQQgXuQeDgbF5LrDoPfG37FhXRNUnE7FRR9mEiNQoGxRk/O5jq5zF8ChyHEIPtFeywd0ajsdP9sbGx7Ny5s9PnIiIiOn0Hfv/+/QwfPtya4Qlh18LCwmhpsf47zrNnz+6w/uC5nn/+eRYvXszCheaS0uvXr+ezzz7j9ddfZ9myZQBkZGR0efywYcNITEwkPNx8ffjlL39JRkZGl4lYU1MTTU1Nlsc1NTW9fUlCiIGi0YB3BJQdM09PlETMbsnURDtVftp8M3mBQxiaLgo22JLwGPM6F8GUUllaqHI0ojMbN27klltu4fHHH1c7FCFsxu7du/H09BzQczY3N5Oent6uUIhWq2XWrFns3r27R31MmTKFkpISKisrMZlM7Ny5k3Hjup7GvmbNGry8vCxbWwInhLBRbdMTpYS9XZMRMTvVVHQEgGq3KHUD6SFPbz/yNKGEKwWcydqNz2Udp+IIdS1cuNDy7rsQQ82UKVM6VBWtqKjAx8eHN954Y0BjKSsrw2g0dlhgPSgoiCNHjvSoDwcHB5566ilmzJiBoihceeWVXH311V22X758OUuXLrU8rqmpkWRMCFtm5cqJQh12kYj997//ZebMmZ0+l5aWxpQpU3j88cd54oknOjzv6uqKwWC44DnKy8uJj48nPz+fyspKvL29LzbsfuVQeRKAFu+RKkfScyXuYwivLaAuJx0kERN2ytHJmbT4JwGY6OSscjTCWj788MN2jzUaDX5+fri5ufH+++8TExOjUmR9d6Hpj+fS6/Vyf6gQ9sSKlRPluqYeu0jELrnkEgoL209ne/TRR9m+fTuJiYkAPPzww9xzzz3t2lxxxRVMmTKlR+dYtGgREyZMID8/3zpB9zMPg/kXzylotMqR9FxL4ASo3YG+9IDaoQjRZ45OepKuu1/tMISVRUZGdvncI488wk033TRgsfj7+6PT6SguLm63v7i4mODg4AGLQwhhw6w4IibXNfXY/s1FgJOTE8HBwZbNz8+Pjz/+mIULF1qmkri7u7drU1xcTFZWFosWLbpg/3/729+oqqri4Ycf7u+XYjVBLXkAeIfbz7u07lGTAQiSgh1CCDuiKMqAns/JyYnJkye3K5tvMpnYvn0706ZNG9BYhBA2Su4RGxTsYkTsfJ988gnl5eXd3s/y2muvMXr0aMtill3Jyspi1apVpKamcurUqR6dX+3qUlVlRfhQC0DIiPEDeu6LET7+EtgOw5RiqitK8fINUDskIXqttaWZQ7vMC2KPn349Do5dr+cmBofz7x2zhrq6Ok6cOGF5nJ2dTUZGBr6+vkRERLB06VLmz59PYmIiSUlJrF27FoPBIPdxCiHM2qYm1pdDUx3o3fvclVzX1GOXidiGDRtISUlpt3bSuRobG9m8ebOlxG9XmpqauPnmm3nmmWeIiIjocSK2Zs2aTu9HGyhFpw7iDRThT7C7l2px9JaXbwAFmiBClWLysnbj9bNr1A5JiF5rbmogfudvAahPmi0XrEEiICCg04RLURSqqqqsfr69e/e2u/e5rVDG/Pnz2bRpEzfddBOlpaWsXLmSoqIiEhIS+OKLLzoU8BBCDFHOXuDsDY1V5umJQX1/Y16ua+pRdWrismXL0Gg03W7nV4g6c+YMX375ZbdTDrds2UJtbS3z58/v9vzLly9n3Lhx3Hbbbb2Ke/ny5VRXV1u2vLy8Xh1/sWryDwNQqre/ilZFbmMAqMveq3IkQgjxk9LSUkpKSjpspaWl/bKO2OWXX46iKB22TZs2WdosWbKE3NxcmpqaSE1NJTk52epxCCHsmExPtHuqjog99NBDLFiwoNs2I0a0X6Ru48aN+Pn5cc01XY+mvPbaa1x99dUXfOfw66+/5uDBg5ZqWW33Afj7+/PHP/6xy1EvtatLGUuOA1DvYX8L7zYFxEHdThxLDqodihBiCFuwYAEvv/wyrq6uaocihBB94xMJhRlWqZwo1KFqIhYQEEBAQM/vE1IUhY0bN3LHHXfg6OjYaZvs7Gx27NjBJ598csH+/vnPf9LQ0GB5/MMPP3DnnXeya9cuRo603bLwztXm0vWK3yiVI+k996hEyIbAup6thSOEEP3hrbfe4s9//rMlEbv33ntZs2ZNu6VLWltbcXCwyxn8QoihQNYSs3s9npq4YMEC6uvr+zOWC/r666/Jzs7mrrvu6rLN66+/TkhISKdrp2zZsoWxY8daHo8cOZLY2FjLNny4eYRp3LhxBAYGWv8FWIlv42kAXEPGXqCl7QmLMVf8ClcKqK2uUDkaIcRQdX4lxM2bN1NR8dPfpOLiYjw9PQc6LCGE6DkrriUm1NHjROytt96irq7O8vjee+/tcANza2ur1QLrzIYNG7jkkkvaJVPnMplMbNq0iQULFqDT6To8X11dzdGj9l06vbWlmRBjAQD+UbEqR9N7PgEhFGEeBT19aI/K0QghhFlnJeobGxtViEQIIXpI7hGzez1OxGzh3cN33nmH7777rsvntVoteXl5rF69utPnFyxY0O16MG03T587NcXWFOUew0ljpFFxJDjc/qYmAhS6mhehrpWCHT122WWXdVrM5o477lA7NCEGrf4oWy+EEFbjHWX+WJULA7zeobCOPk9+l3cP1VF+OoswoFA3jOGdjPrZg8aAOMj9Dofi/WqHYhcUReHHH3/k2Wef5dZbb233nLt739cNEX3j6ORM6rjlAExyclY5GnEx3nnnHWbMmEFcXJzaoQghRO95hwMaaKkHQxm49219VrmuqceqdyHLu4f9r6HQXOSi0jUC+6uZaOYaORlyIaDOvqeJDpTjx49TW1vLjBkzCA4OVjucIc/RSU/yTd2vUShs3/Tp03nssceora3F0dGR1tZWHnvsMS699FISEhJ6VUhKCCFU4aAHjxCoLTCPivU5EZPrmlp6lYjJu4fq01ScAKDJy3arOl7IsJhpsBPCjWcw1Fbh5uGtdkg2LT09HQcHByZMmKB2KEIMGt988w1gfqMjPT2dffv2sW/fPv7whz9QVVUlbywKIeyDT5Q5EavMgbBEtaMRvdTjREzePbQN7rXZADgEjlY5kr7zDw6nBF8CNRXkZaUxNvlK1WIxGAwAuLq6Wv7xam5upqWlBQcHh3brxbW1dXFxQas1317Z0tJCc3MzOp0OZ2fnbtv21b59+zAajfj5+bXbf+utt/LKK6/g4OBAbOxPhVt2796Ni4sLZ86c4YEHHmD//v34+PgwfPhwXnrpJYKCgvD396esrOyi4hqqjK2tHEn9EoCxySnopLy5XYuOjiY6Oprf/OY3ln3Z2dns3buXH3/8UcXIhBCiB3wi4fT3F1WwQ65r6unxV1rePbQNgc15AHiFx6gcycUpcB1DYP1uqk79AComYm33WJWUlFjeTHjmmWdYsWIFd911F6+++qqlbWBgIPX19WRnZxMVFQXAunXr+H//7/9xyy23sHnzZkvbqKgoysrKyMzMZPz48RcV4759+7j55ps7LDDu6+sLgLe3NxkZGe2eUxSFefPmcd999/HRRx8BsGvXLkpLSy+40LnoXlOjgfFf3QJAffxpXN29VI5IWNvw4cMZPnw4v/rVr9QORQghumeFtcTkuqaeXqe88u6hemqrKwigEoCg4fZXuv5cDX6xUL8bXdEBtUOxefv27WP16tWMGtXzKpnbt2/H3d2dRYsWWfZNnz69P8ITQgghhFqkhL1ds8rYo7x7ODCKTmXiAZTjhZ+Pv9rhXBSXyMmQ9yr+tYdVjaNtbTxXV1fLvkceeYQHH3wQh/OG5ktKSgDzdMM2v/vd71i8eHGHdetycnI6tO2LU6dOUVVVRXx8fJdtqqqqSEhIACAxMZHXXnuNrKwsJk2adFHnFkIIIYSNk0Wd7ZpMArUj1XlZABQ7huN3gba2LnTcVPgWIoynaTDU4uLmoUocbm5uHfY5OTnh5OTUo7aOjo44Ojr2qG1fpKenAxAUFERRUVG75wIDA9FqtZ1OTRRC9N6xY8cYMWJEhzdhhBDCZrVNTaw+A8ZW0MnfL3tycVUExIBqLTkGQJ17lLqBWEFASCRleKPTKOQeTlM7HJu1b98+wDwlOCQkxLJFRUXR2tra5XHjxo2TqcJC9NK4ceM4deqU2mEIIUTPeYSAzgkUI9Tkqx2N6CVJxOyIY9VJAEx+Pb9XyFZptFrynaMBqD65V+VobNeaNWtQFKXD1tjY2OmoXZtZs2ZRU1PDpk2bLPu+/fZbMjMzByBqIeyToihqhyCEEL2j1YJ3hPlzuU/M7kgiZke8G04D4Bw8VuVIrKPe37wenaYwQ91ABiGNRsPWrVvZunUrI0eOZPz48bz44ouyzIQQQggx2FihcqJQh0wktRMmo5GQ1nzQgF+kfZeub6MPnwRnXsev9ojaodi1rtYDi4iIYOvWrb06RlyYg6OePSN/D8AkR/0FWgshhBD97CILdsh1TT2SiNmJkoJsgjVNtCg6giMHx4hY6LipsBsiWnNpbDDg7GKdAhdC9CcnvTNTb1+ldhhCCCGE2UWWsJfrmnpkaqKdKM0+BEChLhhHp8HxbkVQ2Egq8cBRYyTvSLra4QghhBBC2B+Zmmi3JBGzE/WF5vW2KpwjVI7EejRaLXnOowGoOCGVE4V9MLa2cmzfNxzb9w3GbipXCiGEEAPiIqcmynVNPTI10V6UHQeg0XOEyoFYl8F3PBSkQ+F+tUMRokeaGg2M/uQaAOpHn8bV3UvliIQQQgxpbSNihhJorgcn114dLtc19ciImJ1wqc0GQBsQrXIk1qUPnwSAb3WWypEIIYa6//3f/8XPz0/tMIQQondcfEB/NnmS6Yl2RRIxOxHQaC5d7z5snMqRWFfQmKkARLbm0NzU2K/nMplM/dq/sE3yfRc9tWbNGknEhBD2R6MBn7a1xCQRsycyNdEONNbXEaSUgQaChseqHY5VhUaNoQY3PDUGThxJZ1T8pVY/h5OTE1qtloKCAgICAnByckKj0Vj9PMK2KIpCc3MzpaWlaLXabhfAFkIIIeyadyQUHZQRMTsjiZgdKDh1iBEahRrc8A0IVTscq9JotZzWRxPblEHFiR+gHxIxrVbL8OHDKSwspKCgwOr9C9vm6upKREQEWq1MABBCCDFIXWQJe6EOScTsQFWe+f6pQocwPAfhP5N1PuOhKAOl4Md+O4eTkxMRERG0trZiNBr77TzCtuh0OhwcHGQEVAghxOBmScRkRMyeSCJmB5qKjwJQ4xalbiD9xCF8IhRtxrv6cL+eR6PR4OjoiKOjY7+eRwhh+xYsWMDLL7+Mq2vvqosJIYRNkrXE7NLgG14ZhBwqTwJg9BmlciT9w1Kwo+UUrS3NKkcjRPccHPXsDl/M7vDFODgOjsXVh6K33nqLuro6y+N7772Xqqqqdm1aZT0dIYS9OHctMUXp1aFyXVOPJGJ2wMuQA4BT8Gh1A+knw4bHUKe44KxpIe9Y/01PFMIanPTOTFv0LNMWPYuT3lntcEQfKef9o7J582YqKiosj4uLi/H09BzosKzqL3/5C+PHjycmJoYHHnigw2sWQgwi3merJjbXQn1F923PI9c19UgiZuMUk4ng1jMA+IQPrtL1bbQ6Hbl682hf6bE0laMRQgxFnSUpjY39u6RGfyotLeWll14iPT2dgwcPkp6ezp49e9QOSwjRXxxdwD3Y/HlVjqqhiJ6TRMzGlZfk40k9JkVDyPDxaofTb2p9zK9NKchQNxAhLsBkNJJzeC85h/diksIvg5q9F3lpbW2lsbGRlpYWWlpaCAwMVDskIUR/Ond6Yi/IdU09kojZuJLsTACKtAE4u7qrHE3/cRg2EQCvqiyVIxGie40NdUS9fwVR719BY0PdhQ8QNuudd95h3759tLS0DPi5d+7cydy5cwkNDUWj0bB169YObdatW0dUVBTOzs4kJyeTltbzGQMBAQE8/PDDREREEBoayqxZsxg5cqQVX4EQwub0sWCHXNfUI1UTbVxdvrmSYJk+gsG1glh7AaOTYB9ENJ/E2NqKzkF+NIUQ/Wf69Ok89thj1NbW4ujoSGtrK4899hiXXnopCQkJBAQE9Ov5DQYD8fHx3HnnnVx//fUdnn///fdZunQp69evJzk5mbVr15KSksLRo0ctI1sJCQmdFhTZtm0bLi4ufPrpp+Tk5ODi4sLs2bPZuXMnM2bM6NfXJYRQkawlZnfkv10bZyo9BkC9x3CVI+lfYaMmUK/ocdU0kXt8P5HjJqsdkhBiEPvmm28AOH78OOnp6ezbt499+/bxhz/8gaqqqn6fljh79mxmz57d5fPPP/88ixcvZuHChQCsX7+ezz77jNdff51ly5YBkJGR0eXx//jHPxg1ahS+vr4AzJkzhz179nSZiDU1NdHU1GR5XFNT09uXJIRQWx+nJgr1SCJm45xrsgHQ+EerHEn/0jk4kOs0knEtWZQeT5NETAgxIKKjo4mOjuY3v/mNZd+pU6dIT0/nxx/VqeLa3NxMeno6y5cvt+zTarXMmjWL3bt396iP8PBwvv/+exobG3F0dOS///0vd999d5ft16xZwxNPPHHRsQshVCRridkdScRsnF/jaQDcQseqHEn/q/YeD6VZaI9+RvGZKwkKk/sZhBADb8SIEYwYMYJf/epXqpy/rKwMo9FIUFBQu/1BQUEcOXKkR31MnTqVX/7yl0ycOBGtVssVV1zBNddc02X75cuXs3TpUsvjmpoawsPDuz2H0WhU5f46oR6dToeDg4PdF7IZtNqmJlblgckIWp2q4YgLk0TMhrU0NxFsKgYNBAyPVTucfqdtMQAwybAL46uTSZvwOEk3PKhuUEKIQWf48OF9+kfywQcf5IEHHuiHiPrH6tWrWb16dY/a6vV69PqeL+RaV1fHmTNnZG2yIcjV1ZWQkBCcnJzUDkWczzMUtI5gaoGaAvDu/s0UoT5JxGxYYc5hIjRG6hU9gaGD+x6x4jMnmVz5bzj7v5FOozDpwBMUJ8+VkTEhhFVt2rSpT8dFRUVZNY6u+Pv7o9PpKC4ubre/uLiY4ODgAYmhO0ajkTNnzuDq6kpAQICMjgwRiqLQ3NxMaWkp2dnZREdHo9VK8W2botWBVxhUZpunJ0oiZvMkEbNhFblZRACFDsMYOcj/2JXmZhGkaf/OqoPGRFnuEUnEhE1xcNSzJ/hWACY59nwEQdiOyy67TO0QuuXk5MTkyZPZvn071157LQAmk4nt27ezZMkSdYMDWlpaUBSFgIAAXFxc1A5HDCAXFxccHR3Jzc2lubkZZ2dntUMS5/OJNCdilbkQ9bMeHSLXNfVIImbDGovM9wJUuUaqHEn/C4iMwaho0J2TjBkVDf6Rg//eOGFfnPTOTL3nZbXDEHaurq6OEydOWB5nZ2eTkZGBr68vERERLF26lPnz55OYmEhSUhJr167FYDBYqijaAhkJG5pkFMzG9aGEvVzX1COJmA3TVpgv0s3eg39EKChsJGkTHmfSgSdw0JgAKNAGMywkSt3AhBCiH+zdu5eZM2daHrcVypg/fz6bNm3ipptuorS0lJUrV1JUVERCQgJffPFFhwIeQgjRjlROtCuSiNkwj7ocABwDR6sbyABJuuFBipPnkrf/a2LS/kg4hez54P+YevMf1Q5NCAuT0UhRnvlNkuDwUWh1UpVK9N7ll19+wUIXS5YssYmpiEIIO9KHtcTkuqYeGV+2YUEteQB4hceoHMnACQobSeKcxRwc/zAAE468QP6pQypHJcRPGhvqCN2UROimJBob6tQORwghhPhJH6YmynVNPZKI2ajqilJ8qQEgZMTgL11/vik3PMQhpwm4apqoeu8eTEaj2iEJIYQQg05VVRWJiYkkJCQQGxvLq6++qnZI4mJ4R5k/1hVBS4OqoYgLk0TMRhWeOgBACb64e/qoHM3A0+p0eP/m79QresY3H+CHfz6ndkhCCCHEoOPh4cHOnTvJyMggNTWVp556ivLycrXDEn3l6gtO7ubPq/LUjUVckCRiNqr2jLliYqnT0F0DYtiIcRwY+3sAYg89R2HuUZUjEkIIYe+WLVuGXq/nlltuUTsUm6DT6XB1dQWgqakJRVFkoW57ptFIwQ47IomYjWotPQZAncfgXsj5QpJ+vYzDjuNx0zRS9s49KCaT2iEJIYSwY8uXL+e5557j3XffbbeEgC3auXMnc+fOJTQ0FI1Gw9atWzttt27dOqKionB2diY5OZm0tLRenaeqqor4+HjCwsJ45JFH8Pf3t0L0QjV9uE9MqEMSMRulrzoFgOI7+EvXd0er0+H+67/RqDgS17SPH7a8oHZIQggh7JiXlxeLFi1Cq9Vy8OBBtcPplsFgID4+nnXr1nXZ5v3332fp0qU89thj7Nu3j/j4eFJSUigpKbG0abv/6/ytoKAAAG9vb/bv3092djbvvPMOxcXF/f7aRD+yVE7MUTUMcWGSiNkonwbzcLJLiCxoHB4dT0b07wAYd+Bpis+cVDkiIYQQ9qy1tRVXV1cyMzPVDqVbs2fP5sknn+S6667rss3zzz/P4sWLWbhwITExMaxfvx5XV1def/11S5uMjAwyMzM7bKGhoe36CgoKIj4+nl27dvXbaxIDQKYm2g1JxGyQsbWVUKP5XSr/qPEqR2MbpvzmUY46jMFD00DRZpmiKNSjc3Ak1f96Uv2vR+fgqHY4Qti1wuoGvj9ZRmH1wFZ3W7FiBXV1dQOWiD311FO4u7t3u50+fbrX/TY3N5Oens6sWbMs+7RaLbNmzWL37t096qO4uJja2loAqqur2blzJ2PGjOl1LMKG9HItMbmuqUcWdLZBxXknCNW00Kw4EBwhfwwBdA4OON/wN5rfu5L4hjR++ORvTLn2d2qHJYYgvbMryUs2qh2GEDZDURQaWnq/xMg/08/w2CeHMCmg1cAT14znhslhverDxVGHRqPp1THp6emsX7+eOXPmDFgids899/DrX/+62zbnj071RFlZGUajkaCgoHb7g4KCOHLkSI/6yM3N5e6777YU6bj//vuJi4vrdSzChljuEetZIibXNfVIImaDynIyCQUKdCFEOci3qE3kuMnsHvFbpmWvY0zGasqSrsY/NFLtsIQQYkhraDESs/LLi+rDpMCjHx/i0Y8P9eq4rFUpuDr1/DppMpn47W9/y5IlS0hOTua2226jpaUFR8eejwIUFBTwyCOPsHnz5h4f4+vri6+vb4/bD6SkpCQyMjLUDkNYk3eE+WNTNTRUgsvQWwbJXsjURBtUX2h+F6vSRZKM80255XGO60bhiYG8t2WKohh4islERUk+FSX58vMnhJ158cUXKSsrY9WqVcTFxdHS0tLjkaM2oaGhvUrCoP+mJvr7+6PT6ToU1yguLiY4OLjX/YlBwskN3ALMn/dgVEyua+qR4RYbpCk/DkCj1wiVI7E9Do5OOFz/Ms0fzGZi/ffs/fw1Eq++W+2wxBDSUF+L78sxANQ/fBpXdy+VIxJCXS6OOrJWpfTqmKLqRmY9/w2mc5ar0mrgP0svI9jLuVfn7qn8/HweffRR3n33Xdzc3IiOjkav15OZmUlcXBw5OTnMmzeP2NhY0tLSmDVrFikpKaxZswaDwcCWLVuIjo4mJyeHG2+8kQ8//JB58+aRkJBAWloaEyZM4L333ut0qmR/TU10cnJi8uTJbN++nWuvvRYwj/pt376dJUuW9Lo/MYj4RIGh1Fw5MTSh26ZyXVOPJGI2yK0uBwBdwGh1A7FRw8cnszvyLqadfoWRe1dRljgb/+Chu/C1EEKoSaPR9Gp6IMCIAHfWXB/HHz7KxKgo6DQanro+lhEB7v0UJTzwwAPMnj2bOXPmAODg4MC4cePa3Sd2+PBhPvjgA0aNGkVsbCzu7u6kpqbyyiuv8NJLL/HCC+2XUDl8+DDvvvsu48aNY+bMmXz77bdMnz69w7n7OjWxrq6u3Vpn2dnZZGRk4OvrS0SEefrZ0qVLmT9/PomJiSQlJbF27VoMBgMLFy7s9fnEIOIdCWd+kMqJNk4SMRsU0JQHgGfYOJUjsV2Jt/2Jk09vY6Qxm31v34f/w/9SOyQhhBC9cNOUCGaMDiCnrJ4of1dCvFz67VyffvopX3/9NYcPH263Py4url0iNmbMGEvFwHHjxlmqEcbFxfH555936HfMmDHExJhHEiZOnEhOTk6niVhf7d27l5kzZ1oeL126FID58+ezadMmAG666SZKS0tZuXIlRUVFJCQk8MUXX3Qo4CGGmF5WThTqkETMxtTXVRNEOQAhI6RqUVccnfQo16yj5aO5TKrbyb5/b2TSbHn3Twgh7EmIl0u/JmBtrr76aiorKzvsf/PNN9s91uv1ls+1Wq3lsVarxWjsWBny3PY6na7TNhfj8ssvR1GUC7ZbsmSJTEUU7claYnZBinXYmIKT5nfmKvHAy0/ezerOqPhL2Rs+H4Co1JVUlhaqHJEQQgghhA2wlLDPUTMKcQGSiNmYqjNZABQ7yj1PPTHpttXkaCPwpYaTb8q6YkIIIYQQlqmJVadBKiHaLJmaaGNaio8BUOMWpW4gdkLv7Erz1S9h/HgeibXb+XHb20y88ja1wxJCCGFnoqKi2Lt3r+Xxhx9+aPl86tSpfPrppx3andv+2WefHaBIhegBzzDQ6MDYDHVF4Nn7qpyi/9nFiNh///tfNBpNp9sPP/wAwOOPP97p825ubhfsf9OmTUyYMAFnZ2cCAwP53e/UG1lxrDwJgNF3lGox2JvRky4jLfR2AMK//yPV5cUXOEKIvtM5OPKD11X84HUVOoeeLwIrhBBCDBidA3iFmT+/wPREua6pxy5GxC655BIKC9vf//Poo4+yfft2EhMTAXj44Ye555572rW54oormDJlSrd9P//88zz33HM888wzJCcnYzAYyMnJsWr8veFdbz63c/AY1WKwRxPv+D9yn/maSNMZfnjzfqb8vw/UDkkMUnpnV6b8v/fVDkMIIYTonk+kuVhHZS5EXtJlM7muqccuEjEnJ6d2K8S3tLTw8ccfc//991sWTmxbmb7N/v37ycrKYv369V32W1lZyYoVK/jXv/7FFVdcYdk/YcKEfngVF6aYTIS05oMGfCNiVInBXjm7uNEw+wVMn97IlOov2f/1e8T//DdqhyWEEEIIoQ6pnGjz7GJq4vk++eQTysvLu12s8LXXXmP06NHdrufx1VdfYTKZyM/PZ9y4cYSFhfHrX/+avLy8bs/f1NRETU1Nu80aSgtzcdM00qpoCRkuiVhvjZ0yi7Rgc/IVsnM5NVXlKkckBiPFZKK+rpr6umoUuQFaCCGErerhWmJyXVOPXSZiGzZsICUlhbCwsE6fb2xsZPPmzSxatKjbfk6dOoXJZOKpp55i7dq1fPjhh1RUVPCLX/yC5ubmLo9bs2YNXl5eli083DoVDkuyDwJQpA3CSe9slT6Hmvg7nuGMJoRAKjjyxv1qhyMGoYb6WlyfjcD12Qga6mvVDkcIIYTonM9w88cL3CMm1zX1qJqILVu2rMsiHG3bkSNH2h1z5swZvvzyy26TrC1btlBbW8v8+fO7Pb/JZKKlpYW//vWvpKSkMHXqVN59912OHz/Ojh07ujxu+fLlVFdXW7YLjaD1lKHgKADlzhFW6W8ocnHzoCZlLSZFQ1LlZxz85iO1QxJCCCGEGHgyNdHmqXqP2EMPPcSCBQu6bTNixIh2jzdu3Iifnx/XXHNNl8e89tprXH311QQFdb8gckhICAAxMT9NAwwICMDf35/Tp093eZxer0ev13fbd18oZccBaPAcbvW+h5KYqVeRmn4DyaUfErDjf6ibOBN3Tx+1wxJCCCGEGDhtUxNrCqC1CRys/7+ruDiqJmIBAQEEBAT0uL2iKGzcuJE77rgDR8fOy2tmZ2ezY8cOPvnkkwv2d+mllwJw9OhRyzTHiooKysrKiIyM7HFc1uJScwoAjX/0gJ97sImb/zwFz+0iVCkm9Y0HSb7/DbVDEkIIIYQYOG4B4OgKLfVQfQb8RqodkTiPXd0j9vXXX5Odnc1dd93VZZvXX3+dkJAQZs+e3eG5LVu2MHbsWMvj0aNHM2/ePH7/+9/z/fffk5mZyfz58xk7diwzZ87sl9fQHf8m8yice+i4AT/3YOPq7kXFFebFNZPLt5L57YUTcyGEEEKIQUOj+Wl6YmW2urGITtlVIrZhwwYuueSSdsnUuUwmE5s2bWLBggXodLoOz1dXV3P06NF2+958802Sk5OZM2cOl112GY6OjnzxxRddjrj1l6bGeoJNJQAEDY8d0HMPVrE/u4ZUv3kA+G5/GENtlboBCSGEEEIMpB5WThTqsKtE7J133uG7777r8nmtVkteXh6rV6/u9PkFCxagKEq7fZ6enmzYsIHKykrKy8v56KOPrFYFsTcKs7PQaRTqFBf8ggf+/INVzB1rKcKfUKWYzDcfUjscIYQQQoiBIwU7bJpdJWKDWeXpQwAUOoah0cq3xVo8vHwpufzPACSXfkjWni9UjkjYO63OgX3uM9jnPgOtTtXbbIXguuuuw8fHhxtvvLHDc59++iljxowhOjqa1157TYXohNqqqqpITEwkISGB2NhYXn31VbVDEgPNJ8r8sZsS9nJdU498tW1EY5F5ymS168AXCRnsJlx+A2kZH5JU9TmeXz5IQ9wPuLh5qB2WsFPOLm5MevhfaochBAC///3vufPOO3njjfYFiVpbW1m6dCk7duzAy8uLyZMnc9111+Hn56dSpEINHh4e7Ny5E1dXVwwGA7GxsVx//fXyczCU9GBqolzX1CNDLzbCoeIkAC0+o1SOZHAaM/9FSvAlTClk/5uPqB1OjxWfOUnmd/+i+MxJtUMRQtigyy+/HA+Pjm8spaWlMX78eIYNG4a7uzuzZ89m27ZtKkQo2pSXlxMYGEhOTs6AnVOn0+Hq6gpAU1MTiqK0u0XjN7/5Dc8999yAxSNUIFMTbZokYjbC05ADgFPQaHUDGaS8fPwpnLEGgKSi9zjyw39UjujCUv/xHAGvTib2q9vwf3Uyaf9cq3ZIQohe2LlzJ3PnziU0NBSNRsPWrVs7tFm3bh1RUVE4OzuTnJxMWlqaVc5dUFDAsGHDLI+HDRtGfn6+VfoWfbN69WrmzZtHVFQU0LOfD7j4n5Gqqiri4+MJCwvjkUcewd/f3/LcihUrWL16NdXV1X19WcLWtY2INVRCo3yfbY0kYjYiqPUMAN7h41WOZPCK//lv+MHrSrQaBZd//57GBoPaIXWqoiSf3euXkJS5Cq3G/M6lTqMw+cDjMjJmA+rrquFxL3jcy/y5EF0wGAzEx8ezbt26Tp9///33Wbp0KY899hj79u0jPj6elJQUSkpKLG3a7u05fysoKBiolyGsoL6+ng0bNrBo0SLLvgv9fIB1fka8vb3Zv38/2dnZvPPOOxQXF1uOjY2NZeTIkbz99tv98KqFTdB7gOvZqahdTE+U65p6JBGzAZWlhXhTB0DIcFlDrD+NvuMlyvAm0nSGH99apnY4ForJxNG9X/PDX36F+7oJTCt6C42mfRudRuHMew/JH0kh7MTs2bN58sknue666zp9/vnnn2fx4sUsXLiQmJgY1q9fj6urK6+//rqlTUZGBpmZmR220NDQbs8dGhrabgQsPz+/22Oampqoqalptw1Gv/rVrwgICODvf/+7ZV9qaipOTk79OnXz888/R6/XM3XqVMu+C/18gHV/RoKCgoiPj2fXrl3t9s+dO5f33nvPSq9U2CSZnmizJBGzAcWnDgJQhD+u7l4qRzO4efkFkXeJeXmDKflvc/zHnarG01hfR9qWFzmxegpjPr2OKdXbcNK0ckobhUnRdGg/uW4H1c9OZv/XH6gQrRDCWpqbm0lPT2fWrFmWfVqtllmzZrF79+6L7j8pKYnMzEzy8/Opq6vj3//+NykpKV22X7NmDV5eXpZNjWVcBsJf//pXbrjhBlatWgVAXV0dt912G/feey9XXnllv513165dTJ48uVfHWONnpLi4mNraWsC8lurOnTsZM2ZMuzZJSUmkpaXR1NTUq/iEHZG1xGyWJGI2oDb/MACl+sF54bM1E6+8jXSPn+OgMeHwryU0NdYPeAwF2UfYs/4+Gv88hqT9K4g2nqBJceQHrxSOXfMxI1buZ++Ex2lVzL+irYqWPQE3UkQAIZQSv3Mx+569hrIC+aMqhD0qKyvDaDQSFBTUbn9QUBBFRUU97mfWrFn86le/4vPPPycsLMzyD7qDgwPPPfccM2fOJCEhgYceeqjbSnnLly+nurrasuXl5fX6NdU3t3a5NbYYrd62L0JCQnjwwQfJz8+nvLycBx54AL1ez9NPP92n/noqNzf3gqOY57PGz0hubi7Tp08nPj6e6dOnc//99xMXF9euTWhoKM3Nzb36uRN2pgcl7IU6pHy9DWgtPQZAvcdwlSMZOkbc8TIV65IYbsplz9srmHrX8/1+TpPRSObOLZjSXmVCfSqhZ+//KiKA7OE3MWb2fUwJ/Onm+qQbHqQ4eS5luUfwjxzL1LCRGGqr2PP2MqYUvcekum+o+ftUUmOWMuWGpWh1un5/DUII2/Kf/3RdeOiaa67hmmuu6VE/er0evV5/UbHErPyyy+dmjglg48Iky+PJf/oPDeclXG2Sh/vy/m+nWR7/7OkdVBiaO7TL+b85fYpz9OjRuLq6snLlSjZv3kxaWhrOzs596qunGhoa+v0cnUlKSiIjI6PbNi4uLoD5PjYxSMnURJsliZgNcK4+BYDiF61yJEOHT0AI6Umr8E17kMl5mzh54EZGTrikX85VXVHK4X+/TNiJd5mgFJp3auCA82RMk+8ibuavCXbo/FcxKGwkQWEjLY/dPLyZeu96Tuy/HeVfvye69TjJWU9y5Ng/0V//IsNjpvTLaxBCWJe/vz86na5d4QQwTyULDg5WKaqhQavVEhcXx8svv8yf//xn4uPj+/2c/v7+VFZW9vqYgfgZqaioACAgIMBqfQobI1MTbZYkYjbAt/E0AG6hY1WOZGiZ/MuF7Dv0EZMMO+Hj39Eydg+OThf3jvC5Th74nvId64ir2MZUjfnd3BpcyQq8mmG/WMKE6L5f/EfFX4px/B72/ONp4o78lbGth2l5P4Xdw24l4danZMFqIWyck5MTkydPZvv27Vx77bUAmEwmtm/fzpIlS9QNro+yVnV9D5r2vOpD6Y/O6qJlx7bf/u/MiwvsPG3raE2aNImHHnrIsj8nJ4d58+YRGxtLWloas2bNIiUlhTVr1mAwGNiyZQvR0eY3TK+++moKCwtpampi+fLl3HrrrezevZvf//73fP/995SXl/Ozn/2MXbt2ERwczMSJE3tdmXCgfkYyMzMJCwtrV9ZeDDLnjogpCh2qgQnVSCKmstaWZkKMhaAB/ygpXT/QIm5/mcr10xhpPMXuzSuZtvDi7hNobmrkwFdv4rZ/I+NashgJoIFsbRQl424n9qq7mOrhbY3Q0Tk4MPXmP1KUdxPH3n2AifXfMa3gTfKf/ZKKy/+PuMuut8p5RHtanQP7XcxTrMbo5E+o6FpdXR0nTpywPM7OziYjIwNfX18iIiJYunQp8+fPJzExkaSkJNauXYvBYGDhwoUqRt13rk49/33or7Y9sXbtWlJTU0lISECrbX+r/OHDh/nggw8YNWoUsbGxuLu7k5qayiuvvMJLL73ECy+8AMCbb76Jr68vBoOBKVOmcOONNzJt2jRmzJjB008/zY8//sjKlSstI1cpKSksX76cyspKfHx8gAv/fAAD8jOya9eufi1UImyAVzhotNDaCHXF4NF+RFWuaypSxEWrrq5WAKW6urrXx54+fkBRHvNU6lf6K8bW1n6ITlzID5+sV5THPJWmlT7Kqcw9feqj+MwpZfer/08pfSxCUR7zVJTHPJXmlT7K3mfnKYd2/1sxGY1WjrqjfV++pRQ/FmU5/w/PXa+UFp7u9/MKcbEu5m+oLduxY4cCdNjmz59vafPiiy8qERERipOTk5KUlKTs2dO3v0HW1t33pKGhQcnKylIaGhpUiOziHDhwQNHr9cp9992nODk5KS0tLZbnsrOzldjYWMvj6667Tvniiy8URVGU7777Trnmmmssz61YsUKZMGGCMmHCBMXNzU05duyYoijmr82YMWOUOXPmdDh3UlKSsn79esvjnvx8KEr//ow0NDQoXl5eyu7du3t1jL1+/4e058eb/z/ItY2/MYNdT69rUjVRZeW5hwAo1IVKsQWVTJ6zmB9dL8FJY6T1o/tobel4U3hnFJOJzO/+xb5n5uL790lMPbMBf6ooxYfdEXdT/dsfmfzQVmKmXoVG2/+/ahOvvA3XpfvYE/hrjIqGxJr/4Lg+mbR//gWTsfOb4oUQ/efyyy9HUZQO26ZNmyxtlixZQm5uLk1NTaSmppKcnKxewINcY2Mjt9xyCzfddBNPPvkkzc3NHDlypF2bcwuWaLVay2OtVovx7N/RHTt28N1335Gamsr+/fsZO3aspfR7SUkJzc3NloqH51q5ciUvvPACJpMJ6NnPB/Tvz8jGjRtJSkpqt76ZGKSkYIdNkkRMZY1FRwGoco1QOZKhS6PVEn7bempwI9p4gh/eeaLb9nU1laS+/zS5T04g9qvbmGTYiYPGRJZTHOlJa/H+w1Gm3fkM/qGRA/QKfuLu6cPU+17l1LWfcEI3Ei8MJB18nKP/N53cw+kDHo8QQtiKZcuWYTAYeOmll/Dx8SEyMpK1a9dSUFDQq35qamrw8/PD2dmZjIwM9u/fb3lu8eLFvPjii0yZMoXnnnuu3XFz5szh7rvvbrfQttocHR158cUX1Q5DDARLCXtJxGyJTARVmabcPD+8yWvkBVqK/uQfGskPCX9gSsYfmXxqPblHbiBy7KR2bXKP7KPoPy8yvvTfJGsaAKhX9Bz0n03gz+8jZrztvJMdPXEGrbF72PPBGiYcW8e4lkM0v/cLdofPZ+KtT+Ls4qZ2iHarvq4anjlb4fSR47IIuxB2YNu2baxbt45vvvkGDw9zMaMVK1awbNkyysvL2bJlS4/7uuqqq/jb3/5GTEwM48ePtyzUvGHDBgIDA5kzZw6XX345SUlJzJs3r90Cyg8++KBVX9fFuuuuu9QOQQwUS+XEnA5PyXVNPRpFOVs+SPRZTU0NXl5eVFdX4+np2atjjzyZzNjWI+we/TDTbnm0nyIUPaGYTBz485XEN/7Ace0IGi9/HL+IMRQfTcVx3+vENmVY2p7WDqMg+lZiZt+Dp3fXi6TagsLcoxS/9wAJDXsAyNOEUn3F08T+rGfrC4n26uuqcX3WPIJd//BpuWBZwcX8DRX9o7vvSWNjI9nZ2QwfPlyVtbGEuuT7b6f2vw9b7oao6bDg03ZPyXXN+np6XZMRMRWl/XMtU1qOgAaSjz5H2j89SLrhQbXDGrI0Wi3Bt71C46vJRJtOwdd3oCgQerbKq1HRcMDtEhym/pbYn80lYgDu+7KGkMgxBD/yb/Zte5PwPY8TrhQQ/p/b+eGHFEbe+hd8z1lEWgghhBCDkKwlZpPs4z/JQaj4zEkmH3jcspSDVqMw6cATFJ85qWpcApxotXyu0ZiX3Njjdz2li35g4v98TtyMeQNSfMOaNFotk65agP7BdFL9r8ekaJhS/SWal5NJ2/Iiytmbx4UQQggxCLXdI1ZzBowtqoYifmJf/00OIqW5Weg07WeFOmhMlOUe6eIIMRBKc7PQnvd90WjAY9KNBEdEqxSV9Xh6+5G8ZCPH5v6TU9oofKglaf8Ksv7vMk4fy1A7PCGEEEL0B/cgcHAGxQTVeWpHI86SREwlAZExGJX2K5u3Klr8I8eqFJGAofN9GZt4BeHL0tgz4gEaFCfGNx8gePMV7H79f2hqrFc7PCGEEEJYk0YD3mcrdMv0RJshiZhKgsJGkj7hcVrPLuXWqmjZN+ExgsKkeqKahtL3xdFJz9Q7/kTlgl0ccJ6Ck6aVaadfofjPiRz6/nO1wxNCCCGENbVNT5S1xGyGFOtQUdIND1KcPJey3CP4R44laRD+s2+Phtr3JXT4WEL+Zxvp/36dyB/+RIQpH7bdTFraLxlz+1q8/ILUDtGmaLU6DjnFATBSK4uwCyGEsBPenZewl+uaeiQRU1lQ2MhBOdpi74ba90Wj1TJ5zl1UT5tH6uaHSC7/mKSqz6l48Vv2TvoDYQmzKMs7QkBkzJD6unTG2dWd8X/4Vu0whBBCiN7ponKiXNfUI4mYEMLCyzeA5Pvf5EjqNpy/fIgo02l89y1DSYdgjbmEf9qEx2WZBSGEEMLetI2IydREmyH3iAkhOhibfCWh//sDu4NvQ1GwLLOg0ygkHnicH7e9hbG1tds+hBBCCGFD2u4RO29qolCPJGJCiE456Z3xiLvKkoS10WoUJn6/hNonI9n73HWkbV1HadFpdYJUQX1dNZWPh1P5eDj1ddVqhyOEEEL0TNvUxPpyaKqz7JbrmnpkaqIQoktt5fzPXfPOpEAdLnhr6kis/RoyvoaMP3BcN4rS4On4xM8heuLlODg6qhd4P/OhBgAp9C+EEMJuOHuBszc0VpmnJwaNtzwl1zV1yIiYEKJLnZXz3zvhCVxXnObI7A/YM2wBJ3Tm4h3RxhNckr+RcZ/fiGF1JHufvZbULS9RWjh0RsuEEEIIm9ZFwQ6hDhkRE0J0q6ty/mOTUyA5BYCyotPk7PkY7cntjKpNwwsDiXU7YP8O2P9HjutGUho8A6+42YyePBNHRyc1X5IQQohzZGdnc+edd1JcXIxOp2PPnj24ubmpHZboDz5RULhf7hOzEZKICSEu6ELl/P2DI/C/9n7gfoytLRzZ91+qDnyGf+FORhlPEm08SXT+ScjfSM2/3djvMQXjiCsYPvVaAkMjBu6FCCGE6GDBggU8+eSTTJ8+nYqKCvR6vdohif4ilRNtiiRiQgir0jk4MjbpF5D0CwDKi0+Ts+cTNCf+w8jaNLw0BhLr/gsH/gsHHuWEbgTFQdPxivslYxJ/LqNlQoh+tWzZMv7yl79www038M4776gdjuoOHTqEo6Mj06dPB8DX11fliES/kqmJNkXuERNC9Cu/oAgmz1vCpIe24r4il2Nz/smesDs54TAKgFHGU1xa8AaxX95E/ZNR7H3mGvb88wWK8nPUDVwIMSgtX76c5557jnfffZcTJ06oHU63du7cydy5cwkNDUWj0bB169ZO261bt46oqCicnZ1JTk4mLS2tx+c4fvw47u7uzJ07l0mTJvHUU09ZKXphk9pK2MuImE2QETEhxIDROTgyesosmDILgMqSM2Tv+QROfMWImjRzJUbDN3DwGzi4khPa4RQHzcAzbjZjEq+gsiSP0twsAiJjup0q2Z+0Wh3HHaIBCNfqVIlBCNF3Xl5eLFq0iN///vccPHiQUaNGqR1SlwwGA/Hx8dx5551cf/31nbZ5//33Wbp0KevXryc5OZm1a9eSkpLC0aNHCQwMBCAhIYHWTtZ+3LZtG62trezatYuMjAwCAwO56qqrmDJlCr/4xS/69bUJlXhHmT9W5tC2UKhc19QjiZgQQjU+gWH4XHMfcB+m1laOZ3xDxf7P8Sv8hlGtxxllymZUYTYUvkHDl04E0kyQBoyKhrQJj5N0w4MDHrOzqzvRK/YO+HmFGJSq86HiJPiOBK9hA3ba1tZWXF1d+f/t3XlYVdX6wPHvOcyTKCKTEzihKCKKktrP4UYOGWmDUpmpmZViSRZlg0NehzRzyCHTnErL9N6rppZDhmMKTlgoDhnOCg4ogiDIWb8/iJ1HBkHhHJD38zznqb32e/Z+z+B+WWevvXZcXBxPP/20yfZbXF27dqVr166FxkyZMoWBAwfSv39/AObMmcO6detYsGABw4cPByA2NrbA51evXp2goCBq1qwJwBNPPEFsbKx0xB5WlWsCOsi6CWmXwbGa1DUzko6YEKJM0FtaUj/oMQh6DIBrSef4K/pHOL6Juim7cNb9c3cTC52i+e+fkBgcarYzY0KIvymV80ddccV+Bz+/B8oAOj10nQTNXizeNqzsyXPX+SL4+OOPSU1NJS4urtjPvR/jx4+/55C/w4cPU6tW8SYvyszMZN++fXzwwQdam16vJyQkhF27dhVpGy1btiQpKYnk5GScnZ3Ztm0br7/+erHyEOWIpQ04ecKN8znDEx2rmTujCk06YkKIMqmyW3Wahw4CBhG3bTXOv75stN5SZ+DyqSPSERPC3LJuwnivB9uGMsBP7+Y8iuPD82BdvGnW9+3bx5w5c+jWrZvJOmJvvPEGvXr1KjTGy6v47+Hly5fJzs7G3d3dqN3d3Z0jR44UaRuWlpaMHz+edu3aoZSiU6dOPPnkk8XORZQjVbxzOmLJJ6FGkLmzqdCkIyaEKPOq1WlC9mYdFjqltSkFN68nmTyX9LQbXPssEIDKkQewc3AyeQ5CiPtjMBh4/fXXGTJkCMHBwbz00ktkZWVhZWVV5G2cP3+eyMhIli5dWuTnuLi4lOnZCIsyBFI8RKrUhtO/afcSk7pmPtIRE0KUee416hLTdDTNf/8ES50h9/piGsR8xMk6gXg3bGayXJQy4MklAG4qg8n2K0SZZWWfc2aqOFLOw6xWOWfCcuksIDwaKhXjzJCVfbF2O2PGDC5fvsyYMWM4ffo0WVlZHDlyBH9//yJvw8vLq1idMCi9oYmurq5YWFiQmJho1J6YmIiHh0extiUqkLvuJSZ1zXxk+nohRLnQ6tkIrgzcy6HHv+PcS9s5ZuWLM2lY/dCLS4lnzJ2eEBWXTpczPLA4D9f6EDo9p/MFOf8NnZbTXpztFOP6sHPnzjFixAhmzZqFg4MD9evXx8bGRhueePLkSQICAujduzf169dn0KBBrFq1iuDgYJo0acLx48e1uKCgIC2+b9++NGrUiLCwMJRS+e77jTfeIDY2ttDH/QxNtLa2pkWLFmzevFlrMxgMbN68mdatWxd7e6KCyJ3CXu4lZnZyRkwIUW6416irXROWPHAl577sSHWVyJF5z+Lw9i/YO1Qyc4ZCiCJr/jLUfQyu/gUudUp91sS33nqLrl270q1bNyDn2qhGjRoZXScWHx/P8uXLqVevHk2aNMHR0ZHo6Gi++uorZs6cyfTp0422GR8fz/fff0+jRo3o2LEjO3bs0G6MfKf7HZqYmppqdK+zhIQEYmNjcXFx0c6eDRs2jL59+xIUFESrVq2YNm0aaWlp2iyKQuSh3dT5pFnTENIRE0KUU1XcqpP24gquLX2ChrePsn/WCwQMW42FpRzWhCg3nKubZNr6tWvX8uuvvxIfH2/U7u/vb9QR8/X1xdfXF4BGjRoREhKixf300095tuvr64ufnx8AgYGBnDx5Mt+O2P3au3cvHTt21JaHDRsGQN++fVm0aBEAYWFhXLp0iZEjR3Lx4kWaNWvG+vXr80zgIYQmd2ji9bOQnff+csJ0ZGiiEKLcqlE/gMSu88lUljS/uYOYrwYVODRIiIfV008/TZUqVXjuueeM2s+cOUOHDh3w8/OjadOmrFixwkwZmt+TTz5JcnJynuumvvnmG1avXq0t29jYaP+v1+u1Zb1eT3Z2dp7t3hlvYWGRb8yD6NChA0qpPI/cTliuIUOGcOrUKW7dukV0dDTBwcElmod4yDh5goU1qGxIOWfubCo06YgJIco13+AuxLWaCEDrS8vZ/f04M2ckhGkNHTqUb775Jk+7paUl06ZN4/Dhw2zcuJGIiAjS0tLMkKEQokzR66Hy3xPDyPBEs5KOmBCi3Gve7VWi67wJQPDRyezbsKTU9qXT6Tmpr8lJfU10OjmECvPr0KEDTk55p5v29PSkWbNmAHh4eODq6srVq1dNnJ0Qoky6Y+ZEqWvmI++2EOKh0OqlMeyp2h29TuH329vE740qlf3YOTjhPTIO75Fxcq8VcU/btm0jNDQULy8vdDodq1atyhMza9YsvL29sbW1JTg4mJiYmBLPY9++fWRnZ1OzZs0S3/bDwtvbm71792rL//nPf+jQoQMAjzzyCGvXrjWKuzt+8uTJ9OvXz5QpC3H/tAk7TkldMyPpiAkhHgo6vZ7AN77md7tW2OkycVvbl7N/xd/7iUKUorS0NAICApg1a1a+63/44QeGDRvGqFGj2L9/PwEBAXTu3JmkpH9uVt6sWTOaNGmS53H+fNHu3XX16lVefvll5s6dWyKvSQjxELjrXmLCPGR6MSHEQ8PSypq6g5bz5/THqJd9gtPfPktyeBRVXGX2MGEeXbt2pWvXrgWunzJlCgMHDtSmGp8zZw7r1q1jwYIFDB8+HIDY2Nj73v+tW7fo0aMHw4cPp02bNoXG3bp1S1tOSUm5730KIcoB7V5iJ82ZRYUnZ8SEEA8Vh0pVqDzgfyRSlVrqHOe/eoaM9Jsltv30tBucHNOEk2OakJ52o8S2KyqezMxM9u3bp02RDjmz84WEhLBr164H3r5Sin79+vGvf/2LPn36FBo7YcIEnJ2dtYcMYRTiIXfH0ESpa+YjHTEhxEPH1cub9F7LuIEdjbPi+GN2bwwlNK20Uga8DWfwNpxBKUOJbFNUTJcvXyY7OzvP/Z7c3d25ePFikbcTEhJCz549+emnn6hRo4bWidu5cyc//PADq1atolmzZjRr1ow//vgj32188MEHXL9+XXucOXPm/l+YEKLsyx2amJaEykyTumYmMjRRCPFQ8vZrxaHHvqLBL/1peeNXds5/m7avfWHutIQocb/88ku+7Y8++igGQ9H+qLKxsTG6J5YQ4iFnVwVsnOHWdXTX5YcXc5EzYkKIh1bj/+vOwcBPAGh7fjG7V3xu5oyE+IerqysWFhYkJiYatScmJua58bAQQpQonQ6q5NxLTHf9tJmTqbikIyaEeKgF9XiT6JoDc/4/biwHo/5j5oyEyGFtbU2LFi3YvHmz1mYwGNi8eTOtW7c2Y2ZCiArh7+GJejkjZjbSERNCPPRa9Z/EXufOWOoM1NsSzp+//2bulEQFkZqaSmxsrDbzYUJCArGxsZw+nfML9LBhw5g3bx6LFy8mPj6eQYMGkZaWps2iKIQQpebvmRNlaKL5yDViQoiHnk6vp+ngbzg0pRONbx2k0v96c6HKL3jWrGvu1MRDbu/evXTs2FFbHjZsGAB9+/Zl0aJFhIWFcenSJUaOHMnFixdp1qwZ69evzzOBhxBClDitIyb3EjOXcnFGbMuWLeh0unwfe/bsAWD06NH5rndwcCh023v27OGxxx6jcuXKVKlShc6dO3Pw4EFTvCwhhAlZ29hSc9D/OKWviRtXSV/4DCnXrxZ7OzqdngtU4wLV0OnKxSFUmFGHDh1QSuV5LFq0SIsZMmQIp06d4tatW0RHRxMcHGy+hIUQFYc2NPGs1DUzKRfvdps2bbhw4YLR49VXX8XHx4egoCAA3n333Twxfn5+9OzZs8Dtpqam0qVLF2rVqkV0dDQ7duzAycmJzp07k5WVZaqXJ4QwkUqVXbHp9z8uU5k6hpOcmv0smXfcxLYo7Byc8Bz9J56j/8TOwamUMhVCCCFKWZV/OmKeo45LXTODctERs7a2xsPDQ3tUrVqV1atX079/f3Q6HQCOjo5GMYmJiRw+fJgBAwYUuN0jR45w9epVxowZg6+vL40bN2bUqFEkJiZy6pScphXiYeRRqwHXeizhprLB/9Z+DnzZD1XEKb6FEKK8SUhIoGPHjvj5+eHv709aWpq5UxJlReWcWRPJvAHpyebNpYIqFx2xu/34449cuXKl0IuZv/76axo0aMD//d//FRjj6+tL1apVmT9/PpmZmaSnpzN//nwaNWqEt7d3gc+7desWKSkpRg8hRPlRr9n/8We7L8hWOoKv/cSuRR+YOyUhhCgV/fr1Y8yYMRw+fJitW7fK/eLEP6zswPHvW2UkJ5g3lwqqXHbE5s+fT+fOnalRo0a+6zMyMli6dGmhZ8MAnJyc2LJlC0uWLMHOzg5HR0fWr1/Pzz//jKVlwfOYTJgwAWdnZ+1Rs2bNB3o9QgjTa/rY8+xrnNMBa3N6DjGrvyzS8zJupnJ8bBDHxwaRcTO1NFMUQjxErly5gpubGydPnjTZPg8dOoSVlZX2o7SLi4vR3zfPP/88n38u91es0P4ennhh/otS18zArB2x4cOHFzgJR+7jyJEjRs85e/YsGzZsKLSTtXLlSm7cuEHfvn0L3X96ejoDBgygbdu27N69m507d9KkSRO6detGenp6gc/74IMPuH79uvY4c0am/RSiPGrV6312e/YGoNn+j4jbsfaezzEYsql/+zj1bx/HYMgu7RSFEA+JcePG0b17d23EzbZt2wgNDcXLywudTseqVavyfd6sWbPw9vbG1taW4OBgYmJiirzP48eP4+joSGhoKM2bN2f8+PFG6z/++GPGjRvH9evX7/dlifLu7wk7PA0Xpa6ZgVmnr3/nnXfo169foTF16tQxWl64cCFVq1blqaeeKvA5X3/9NU8++eQ9p//97rvvOHnyJLt27UKv12ttVapUYfXq1Tz//PP5Ps/GxkZO7QvxkGj16gz2Tz1L89St1PrlNU66rsW7YXNzpyWEeIjcvHmT+fPns2HDBq0tLS2NgIAAXnnlFZ555pl8n/fDDz8wbNgw5syZQ3BwMNOmTaNz584cPXoUNzc3AJo1a8bt27fzPHfjxo3cvn2b7du3Exsbi5ubG126dKFly5Y8/vjjADRp0oS6deuyZMkSwsPDS+GVizLv7ynshXmY9YxYtWrVaNiwYaEPa2trLV4pxcKFC3n55ZexsrLKd5sJCQlERUXdc1gi5BwY9Xq9NuEHoC0b5OJ9ISoEvYUFfoO/44iVH5VIw2ZZLy5fOG3utIQQpaBnz55Uq1aNuXPnam3R0dFYW1uzcePGUtvvTz/9hI2NDY888ojW1rVrV8aOHcvTTz9d4POmTJnCwIED6d+/P35+fsyZMwd7e3sWLFigxcTGxhIXF5fn4eXlRfXq1QkKCqJmzZrY2NjwxBNPaDcXzxUaGsqyZctK/DWLcuLvoYnCPMrVNWK//vorCQkJvPrqqwXGLFiwAE9PT7p27Zpn3cqVK2nYsKG2/Pjjj5OcnEx4eDjx8fEcOnSI/v37Y2lpaXQDTiHEw83W3hGP1/7HWZ0nnlwi+eunSbshQ3WEKJbMtIIfWRnFiE0vWux9+OKLL3j22WcZM2YMkHMbm5deeolBgwbRqVOn+9pmUWzfvp0WLVoU6zmZmZns27ePkJAQrU2v1xMSEsKuXbuKtI2WLVuSlJREcnIyBoOBbdu20ahRI6OYVq1aERMTw61i3spDPCQqS0fMnMw6NLG45s+fT5s2bYw6U3cyGAwsWrSIfv36YWFhkWf99evXOXr0qLbcsGFD1qxZwyeffELr1q3R6/UEBgayfv16PD09S+11CCHKnsrVPEl76T8kf9uF+tl/cmB2GP7D1mBZwNl3IcRdxnsVvK5+J+i94p/lz+pB1s38Y2s/Cv3X/bM8zR9uXskbN7r4P5Z4enoSERHBV199xZUrV4iMjMTGxoaJEycWe1vFcerUKby8Cnl/8nH58mWys7PzXGbh7u6e5/r5glhaWjJ+/HjatWuHUopOnTrx5JNPGsV4eXmRmZnJxYsXqV1b/iivcGRoolmVq47Yd999V+h6vV5f6MQZ/fr1y3NN2uOPP66NlRZCVGzV6zbhaLdF2K99nsD0Xez+6jWCB89Hpy9XgweEEIVo0KAB9vb2jBw5kqVLlxITE4OtrW2p7jM9Pb3U91GQrl275jtKKJednR2Qc7mGqIAqeaF0luhU3usMRekrVx0xIYQobb4tQzhw+TMCdr/NI5f/x67vvGn90iijmGQqASBT9ghxhw/PF7xOd9colcg/C4m964ePiD/uP6d86PV6/P39mT17NpMmTSIgIKBEt58fV1dXkpOLd8NcV1dXLCwsSExMNGpPTEzEw8OjxHK7evUqkHPdvqiA9BYo5+rorp3iBvbkHU8mSpP8zCuEEHcJ7NqfPfUjAAg+PpV9Py/S1tk7OlNl9BmqjD6DvaOzeRIUoiyydij4YWVbjFi7osXeJ6UUAM2bN+edd97R2k+ePElAQAC9e/emfv36DBo0iFWrVhEcHEyTJk04fvy4Fvvkk0/SokULmjRpwtKlSwHYtWsXrVq14vbt2yQmJlK/fn0uXrwIQGBgIIcPHy5WntbW1rRo0YLNmzdrbQaDgc2bN9O6dev7fv13i4uLo0aNGri6upbYNkX5onfxAcCp+2SpayYmHTEhhMhHqxdHEuP6DHqdovHudzmy5xdzpySEKAHTpk0jOjoag8Gg3bomV3x8PCNHjuTIkSNs2bKFnTt3Eh0dzZtvvsnMmTO1uG+++YZ9+/YRHR3NuHHjuHXrFq1bt6Zdu3ZMnDiR8PBwRo4cqZ256ty5M4cOHTI6K5aamkpsbKw2i2FCQgKxsbGcPv3PrK3Dhg1j3rx5LF68mPj4eAYNGkRaWhr9+/cvsfdj+/btpTpRiSgHcq8Tu3bKrGlURNIRE0KIfOj0elq8MZeDdo9gq8vCfV0/zvwZZ+60hBAP4I8//uCDDz5g8ODBHD58OM/9t3x9ffH19cXCwoJGjRppMxb6+/tz8uRJLW7q1KkEBATQpk0bTp8+rXWexo4dy7fffktGRgZ9+vTR4v39/WnevDnLly/X2vbu3UtgYCCBgYFATqcrMDCQkSNHajFhYWFMnjyZkSNH0qxZM2JjY1m/fv0975NaVBkZGaxatYqBAweWyPZEOZU7c2LySbOmURFJR0wIIQpgYWlF/fDlHLesRxVuoFv6HBfP/Mmh8Y9yaPyjZNxMNXeKQogiysjI4MUXXyQsLIyxY8eSmZmZZ/ZBG5t/rvzU6/Xasl6vJzs7G4CoqCjtTNnBgwdp2LChNvV7UlISmZmZ2oyHdxo5ciTTp0/X7lPaoUMHlFJ5HosWLTJ63pAhQzh16hS3bt0iOjqa4ODgEntPFi5cSKtWrYzubyYqnkyHnI79zT/WSF0zMemICSFEIewdnany6kouUI0a6gLJi3rTOPMPGmf+gcGQfe8NCCHKhOHDh5OWlsbMmTOpUqUKtWvXZtq0aZw/X8gkI/lISUmhatWq2NraEhsby8GDB7V1AwcOZMaMGbRs2ZLPP//c6HndunXjtdde49y5cyXyekqClZUVM2bMMHcawswMTtUBsFc3pa6ZmHTEhBDiHlw9apH5/A+kYE+j7H9+Qb98/qT5kgISz54gbucaEs+ekDyEKMTGjRuZNWsWS5YswcnJCYCPP/6YVatWER4eXqxtdenShRs3buDn58e4ceO0GzXPnz8fNzc3unXrxqeffsrixYuN7l0KEBERQc2aNUvmRZWAV199FV9fX3OnIczMcMdNnXXJCWbMBLh+DhK25fy3AuShU7nTB4n7lpKSgrOzM+fPn6dSpUp51ltYWBjdPyQtLa3Aben1eu2eHsWNvXnzJgV9nDqdDnt7+/uKTU9P14ZS5MfBweG+YjMyMvIM3bjfWHt7e3Q6HQC3bt3KM+7/fmPt7Oy0i7kzMzPJysoqkVhbW1vtpuPFic3KyiIzM7PAWBsbGywtLYsde/v2bW1oTX6sra2x+vvGxsWJzc7OJiMjo8BYKysrrK2tix1rMBhIT08vkVhLS0tt+JFSqtB76RyN2UDTLf2x1OXEpmbCXpdQrOu3zxOr1+uw+TsHgPSMgt+z4sTqdDpsbazJPBZFqyurSM8yYFA69ro8mSeP3NiibBfAzvafYVlFjc08FoX/xZWAIlvpONDkQ4J6DDGKvdcxIiUlBS8vL65fv57vMVSYXm5dy+8zycjIICEhAR8fH7PdG0uYj3z+D59bv83BZuP7AChAFzQA6nQwfSJ/bYG9C3KzgKBXzJ+HTg+h06H5y8XaRGHH0DtJR6wE5L7ZBXniiSdYt26dtuzg4FDgH3vt27dny5Yt2nK1atW4fPlyvrFBQUHs2bNHW/b29ubUqfxnvPHz8+PQoUPacuPGjQucSrd27dpGFyW3bNmSvXv35hvr6urKpUuXtOUOHTqwdevWfGPt7e2NOpbdunXjp59+yjcWMOoo9uzZk//85z8Fxqampmp/7PXr14/FixcXGJuUlKTdLyU8PJzZs2cXGJuQkIC3tzcAkZGRTJ48ucDYuLg4GjduDMDo0aP55JNPCoyNiYmhZcuWAHz22We89957BcZGRUXRoUMHAGbNmsWQIUMKjF27di3dunUDYNGiRYXOrLV8+XJ69uwJwIoVK+jVq1eBsQsXLtRuhr5u3TqefPLJAmNnzpyp/cK8ZcsWOnbsWGDspEmTiIyMBGDPnj20atWqwNhRo0YxevRoAA4dOkSTJk0KjH333Xf57LPPgJwpqX18fAqMHTx4MLNmzQLg0qVLuLm5FRjb67ln+N7vF/Q6SMtUOE64UWDsc36WrOj5zw8auk9SCox9or4l6178J9ZhfAo3C+ibt69twZZ+/3Rsqn12g8s38z+MB3np2TPQUVv2nnaDU9fzj/WrpufQ4H9iG89O5fCl/H9Uqe2s42SEk7bccl4qe8/nH1ucY4R0xMoO6YiJgsjn/5C5fg41tTE6pDtQIJ1Fzv0MnasX+SlF7YjJDZ2FEKKIMtKuodcVLfaGrhJHrBrc0bK7wNhUnSNHrBpqy4oYIP+OzU2dPQn6WvgYTue73ihfnR1HrPy05SzdfiD/s6S3dDZGsbd0B4H8zyRm6aw4YuWHTXZqkfIQQghRRl09kX8nrFojsDXhPcUyrsOl+LKZh8qGq38VqyNWVHJGrATI0EQZmljcWBmamKO8DU28cvEU1b9pjcXfQxNvZsFtpedK/+24V69jFFucf/fFPUakXDmP67wWWOgUaZk5/47zy6O0jxGJZ0/gOq8FmbcNGP4OzS8PGZpY/sgZMVEQ+fwfMvmdEbuPM0AlkQfTmoC6oz6U4zzkjJgZODg4GP3BUVhccbZZVHf+EVWSsXf+IVeSscU5gBcn1sbGxmgK4pKKtba21v64N1eslZWV1skpyVhLS0utU1aSsRYWFkX+DhcnVq/Xl0qsTqcrNNahrh/Rfh/Q6vAEdDodNlY6DjUdTasG/vfcdkn+u7erUZeYpqNp/vsnOFgbuK30HGo66p55lPQxwv2OPCx1Rcsjv2NEYT+yCCGEKEXO1cnsNBHrDe+h04FCjy50mmk7P3/nQeh0WBORcwZKZwEVIA85I1YCitrrFUI8HBLPnuDyqSO41m6Ie426kscD5iHH0LJHzoiJgsjn/5C6fi5n+J1LHdN3fh7CPOSMmBBClBL3GnXN2vGRPERZIL/jVkzyuT+knKubt+NTQfOQ+4gJIYQQosjuvL5VVDy519EWdei7EKJgckZMCCGKISM9jaNf9ADA961V2NoV/dovIR4GlpaW2Nvbc+nSJaysrLRJisTDLXcyo6SkJCpXrqx1yEX5J3XNfKQjVoLS0tJwcnLSZuTLnQ3vzlnZcuPAeJa93BnuCpo9rSixubOc3TnLXu4MdwXNnlaU2NxZzu6cZS93hrvixN49K1vuTIj5zbJXlNg7Z8O7c3KD3JkQC5o5716xd86cd+cMi7mfZ3Fii/LZl8T3JL/PsyS+J7mf54N+TwqaifN+vycFfZ4P+j258/MsKNaQfZuA9BiUUlxOuU62oXif/f1+Tx72Y4QoP3Q6HZ6eniQkJBR470rx8KpcuTIeHh7mTkOUoNy6BnAzu+CZpEUpUOKBXb9+XZFzG3CVlJSktY8dO1YB6tVXXzWKt7e3V4BKSEjQ2qZOnaoA9eKLLxrFurq6KkDFxcVpbXPnzlWA6t69u1Fs7dq1FaBiYmK0tiVLlihAhYSEGMX6+fkpQEVFRWltK1euVIBq06aNUWxQUJAC1Nq1a7W2jRs3KkAFBAQYxbZv314Bavny5Vrbjh07FKDq1atnFPvEE08oQC1cuFBrO3DggAKUl5eXUexzzz2nADVz5kyt7dixYwpQzs7ORrF9+/ZVgJo0aZLWdvbsWQUoS0tLo9jBgwcrQI0aNUprS05O1j7PzMxMrf3dd99VgHr33Xe1tszMTC02OTlZax81apQC1ODBg432Z2lpqQB19uxZrW3SpEkKUH379jWKdXZ2VoA6duyY1jZz5kwFqOeee84o1svLSwHqwIEDWtvChQsVoJ544gmj2Hr16ilA7dixQ2tbvny5AlT79u2NYgMCAhSgNm7cqLWtXbtWASooKMgotk2bNgpQK1eu1NqioqIUoPz8/IxiQ0JCFKCWLFmitcXExChA1a5d2yi2e/fuClBz587V2uLi4hSgXF1djWJffPFFBaipU6dqbQkJCQpQ9vb2RrGvvvqqAtTYsWO1tqSkJO3zvNPQoUMVoD788EOVduOaUqMqqdQPnLTY1NRULfbDDz9UgBo6dKjRNuQYkSO/Y8SGDRsUoK5fv65E2ZBb1wr7TLKzs1V6ero8KtDj9u3bJvwWClPJrWtqVKWc/xcPrCjHUKWUkjNiQgghhCg2vV4vs+YJIcQDkOnrS8CdN3T28PCQYUcyNFGGJj7EQxNvZ6ZjP7lWztDEwUewd3SWoYkPeIxITk7GxcVFpq8vQ+SWAkJUHDdTr2M/uVbO/797GntHZzNnVP4V9RgqHbESIAVLiIpDClbJk2No2SOfiRAVh9S1klfUY6hMdSSEEEIIIYQQJibXiJWA3JOKKSkpZs5ECFHabqamcPtWzr/5mykp3DbozJxR+Zd77JQBGmWH1DUhKg6payWvqHVNhiaWgLNnz1KzZk1zpyGEEOXamTNnqFGjhrnTEEhdE0KIknCvuiYdsRJgMBg4f/680T3EiiolJYWaNWty5swZs47DlzwkD8lD8jBXHkopbty4gZeXl9wcuIyQuiZ5SB6Sh+RR+nVNhiaWAL1e/8C/4laqVKlMXBAteUgekofkYY48nJ3l4vCyROqa5CF5SB6SR+nXNfnpUQghhBBCCCFMTDpiQgghhBBCCGFi0hEzMxsbG0aNGmV0M1fJQ/KQPCQPyUOUV2Xl+yB5SB6Sh+RR1vOQyTqEEEIIIYQQwsTkjJgQQgghhBBCmJh0xIQQQgghhBDCxKQjJoQQQgghhBAmJh0xIYQQQgghhDAx6YiZyYQJE2jZsiVOTk64ubnRo0cPjh49atacPv30U3Q6HREREWbZ/7lz53jppZeoWrUqdnZ2+Pv7s3fvXpPmkJ2dzYgRI/Dx8cHOzo66devy73//m9Ke02bbtm2Ehobi5eWFTqdj1apVRuuVUowcORJPT0/s7OwICQnh+PHjJs0jKyuL999/H39/fxwcHPDy8uLll1/m/PnzJs3jbm+88QY6nY5p06aZJY/4+HieeuopnJ2dcXBwoGXLlpw+fdqkeaSmpjJkyBBq1KiBnZ0dfn5+zJkzp0RzgKIdtzIyMggPD6dq1ao4Ojry7LPPkpiYWOK5iLJH6lpeUtekrhUlj7tJXas4dU06YmaydetWwsPD2b17N5s2bSIrK4tOnTqRlpZmlnz27NnDV199RdOmTc2y/+TkZNq2bYuVlRU///wzhw8f5vPPP6dKlSomzWPixIl8+eWXzJw5k/j4eCZOnMikSZOYMWNGqe43LS2NgIAAZs2ale/6SZMm8cUXXzBnzhyio6NxcHCgc+fOZGRkmCyPmzdvsn//fkaMGMH+/fv53//+x9GjR3nqqadKNId75XGnlStXsnv3bry8vEo8h6LkceLECR599FEaNmzIli1b+P333xkxYgS2trYmzWPYsGGsX7+eJUuWEB8fT0REBEOGDOHHH38s0TyKctx6++23WbNmDStWrGDr1q2cP3+eZ555pkTzEGWT1DVjUtekrhU1jztJXctRYeqaEmVCUlKSAtTWrVtNvu8bN26o+vXrq02bNqn27duroUOHmjyH999/Xz366KMm3+/dunXrpl555RWjtmeeeUb17t3bZDkAauXKldqywWBQHh4e6rPPPtParl27pmxsbNT3339vsjzyExMTowB16tQpk+dx9uxZVb16dRUXF6dq166tpk6dWmo5FJRHWFiYeumll0p1v0XJo3HjxmrMmDFGbc2bN1cfffRRqeZy93Hr2rVrysrKSq1YsUKLiY+PV4DatWtXqeYiyh6pa1LXckldK1oeUtf+UVHqmpwRKyOuX78OgIuLi8n3HR4eTrdu3QgJCTH5vnP9+OOPBAUF0bNnT9zc3AgMDGTevHkmz6NNmzZs3ryZY8eOAXDw4EF27NhB165dTZ5LroSEBC5evGj0+Tg7OxMcHMyuXbvMlhfkfG91Oh2VK1c26X4NBgN9+vQhMjKSxo0bm3Tfd+awbt06GjRoQOfOnXFzcyM4OLjQ4SalpU2bNvz444+cO3cOpRRRUVEcO3aMTp06lep+7z5u7du3j6ysLKPvasOGDalVq5bZv6vC9KSuSV0riNS1vKSuGasodU06YmWAwWAgIiKCtm3b0qRJE5Pue9myZezfv58JEyaYdL93++uvv/jyyy+pX78+GzZsYNCgQbz11lssXrzYpHkMHz6c559/noYNG2JlZUVgYCARERH07t3bpHnc6eLFiwC4u7sbtbu7u2vrzCEjI4P333+fF154gUqVKpl03xMnTsTS0pK33nrLpPu9U1JSEqmpqXz66ad06dKFjRs38vTTT/PMM8+wdetWk+YyY8YM/Pz8qFGjBtbW1nTp0oVZs2bRrl27UttnfsetixcvYm1tnecPGHN/V4XpSV2TulYYqWt5SV0zVlHqmuUDb0E8sPDwcOLi4tixY4dJ93vmzBmGDh3Kpk2bSnzsb3EZDAaCgoIYP348AIGBgcTFxTFnzhz69u1rsjyWL1/O0qVL+e6772jcuDGxsbFERETg5eVl0jzKuqysLHr16oVSii+//NKk+963bx/Tp09n//796HQ6k+77TgaDAYDu3bvz9ttvA9CsWTN+++035syZQ/v27U2Wy4wZM9i9ezc//vgjtWvXZtu2bYSHh+Pl5VVqZwTMddwS5YPUNalr5Y3UNalr5jhuyRkxMxsyZAhr164lKiqKGjVqmHTf+/btIykpiebNm2NpaYmlpSVbt27liy++wNLSkuzsbJPl4unpiZ+fn1Fbo0aNSnyWnnuJjIzUfj309/enT58+vP3222b9ZdXDwwMgzww9iYmJ2jpTyi1Wp06dYtOmTSb/1XD79u0kJSVRq1Yt7Xt76tQp3nnnHby9vU2Wh6urK5aWlmb/3qanp/Phhx8yZcoUQkNDadq0KUOGDCEsLIzJkyeXyj4LOm55eHiQmZnJtWvXjOLN9V0V5iF1LYfUtYJJXTMmdc1YRapr0hEzE6UUQ4YMYeXKlfz666/4+PiYPIfHHnuMP/74g9jYWO0RFBRE7969iY2NxcLCwmS5tG3bNs90oceOHaN27domywFyZlDS643/WVhYWGi/EpmDj48PHh4ebN68WWtLSUkhOjqa1q1bmzSX3GJ1/PhxfvnlF6pWrWrS/QP06dOH33//3eh76+XlRWRkJBs2bDBZHtbW1rRs2dLs39usrCyysrJM8r2913GrRYsWWFlZGX1Xjx49yunTp03+XRWmJ3XNmNS1gkldMyZ1zVhFqmsyNNFMwsPD+e6771i9ejVOTk7aOFNnZ2fs7OxMkoOTk1OesfsODg5UrVrV5GP63377bdq0acP48ePp1asXMTExzJ07l7lz55o0j9DQUMaNG0etWrVo3LgxBw4cYMqUKbzyyiulut/U1FT+/PNPbTkhIYHY2FhcXFyoVasWERERjB07lvr16+Pj48OIESPw8vKiR48eJsvD09OT5557jv3797N27Vqys7O1762LiwvW1tYmyaNWrVp5CqWVlRUeHh74+vqWWA5FySMyMpKwsDDatWtHx44dWb9+PWvWrGHLli0mzaN9+/ZERkZiZ2dH7dq12bp1K9988w1Tpkwp0TzuddxydnZmwIABDBs2DBcXFypVqsSbb75J69ateeSRR0o0F1H2SF0zJnVN6lpR85C6VoHr2gPPuyjuC5DvY+HChWbNy1zT/Cql1Jo1a1STJk2UjY2NatiwoZo7d67Jc0hJSVFDhw5VtWrVUra2tqpOnTrqo48+Urdu3SrV/UZFReX7fejbt69SKmeq3xEjRih3d3dlY2OjHnvsMXX06FGT5pGQkFDg9zYqKspkeeSntKb5LUoe8+fPV/Xq1VO2trYqICBArVq1yuR5XLhwQfXr1095eXkpW1tb5evrqz7//HNlMBhKNI+iHLfS09PV4MGDVZUqVZS9vb16+umn1YULF0o0D1E2SV3LS+qa1LWi5JEfqWsVo67p/k5CCCGEEEIIIYSJyDViQgghhBBCCGFi0hETQgghhBBCCBOTjpgQQgghhBBCmJh0xIQQQgghhBDCxKQjJoQQQgghhBAmJh0xIYQQQgghhDAx6YgJIYQQQgghhIlJR0yUK4sWLaJy5crmTqPc8fb2Ztq0aWbZd4cOHYiIiCjWc0aPHk2zZs205X79+tGjR48Szas0mPN9FkKUT1LX7o/UNdOQula6pCMmypWwsDCOHTtm7jSKbMuWLeh0OqpUqUJGRobRuj179qDT6dDpdHnicx/u7u48++yz/PXXX1rMwYMHeeqpp3Bzc8PW1hZvb2/CwsJISkoy2esytenTp7No0SJzp3FPe/bs4bXXXjN3GkKIckTqmtS1skzqWumSjpgoV+zs7HBzczN3GsXm5OTEypUrjdrmz59PrVq18o0/evQo58+fZ8WKFRw6dIjQ0FCys7O5dOkSjz32GC4uLmzYsIH4+HgWLlyIl5cXaWlppngpZuHs7FwufjGuVq0a9vb25k5DCFGOSF2TulaWSV0rXdIRE/elQ4cOvPnmm0RERFClShXc3d2ZN28eaWlp9O/fHycnJ+rVq8fPP/+sPSc7O5sBAwbg4+ODnZ0dvr6+TJ8+XVufkZFB48aNjX55OXHiBE5OTixYsADIO4Qj91T/ggULqFWrFo6OjgwePJjs7GwmTZqEh4cHbm5ujBs3TnvOyZMn0el0xMbGam3Xrl1Dp9OxZcsW4J9f8DZs2EBgYCB2dnb861//IikpiZ9//plGjRpRqVIlXnzxRW7evHnP96tv377aawBIT09n2bJl9O3bN994Nzc3PD09adeuHSNHjuTw4cP8+eef7Ny5k+vXr/P1118TGBiIj48PHTt2ZOrUqfj4+BSaw40bN3jhhRdwcHCgevXqzJo1y2j96dOn6d69O46OjlSqVIlevXqRmJiY573+9ttv8fb2xtnZmeeff54bN25oMWlpabz88ss4Ojri6enJ559/fs/3BuDTTz/F3d0dJycnBgwYkOdX1ruHcNzP9w8gLi6Orl274ujoiLu7O3369OHy5ctG233rrbd47733cHFxwcPDg9GjR2vrlVKMHj2aWrVqYWNjg5eXF2+99Za2/u4hHCXxngohTEPqmtQ1qWtS10xNOmLivi1evBhXV1diYmJ48803GTRoED179qRNmzbs37+fTp060adPH+2AbjAYqFGjBitWrODw4cOMHDmSDz/8kOXLlwNga2vL0qVLWbx4MatXryY7O5uXXnqJxx9/nFdeeaXAPE6cOMHPP//M+vXr+f7775k/fz7dunXj7NmzbN26lYkTJ/Lxxx8THR1d7Nc4evRoZs6cyW+//caZM2fo1asX06ZN47vvvmPdunVs3LiRGTNm3HM7ffr0Yfv27Zw+fRqA//73v3h7e9O8efN7PtfOzg6AzMxMPDw8uH37NitXrkQpVazX8tlnnxEQEMCBAwcYPnw4Q4cOZdOmTUDOZ9O9e3euXr3K1q1b2bRpE3/99RdhYWFG2zhx4gSrVq1i7dq1rF27lq1bt/Lpp59q6yMjI9m6dSurV69m48aNbNmyhf379xea1/Llyxk9ejTjx49n7969eHp6Mnv27Hu+nuJ+/65du8a//vUvAgMD2bt3L+vXrycxMZFevXrl2a6DgwPR0dFMmjSJMWPGaO/Tf//7X6ZOncpXX33F8ePHWbVqFf7+/vnmV1LvqRDCdKSuSV2TuiZ1zaSUEPehffv26tFHH9WWb9++rRwcHFSfPn20tgsXLihA7dq1q8DthIeHq2effdaobdKkScrV1VUNGTJEeXp6qsuXL2vrFi5cqJydnbXlUaNGKXt7e5WSkqK1de7cWXl7e6vs7GytzdfXV02YMEEppVRCQoIC1IEDB7T1ycnJClBRUVFKKaWioqIUoH755RctZsKECQpQJ06c0Npef/111blz5wJfX+52kpOTVY8ePdQnn3yilFKqY8eOavr06WrlypXqzn+Gd8YrpdT58+dVmzZtVPXq1dWtW7eUUkp9+OGHytLSUrm4uKguXbqoSZMmqYsXLxaYg1JK1a5dW3Xp0sWoLSwsTHXt2lUppdTGjRuVhYWFOn36tLb+0KFDClAxMTFKqfzf68jISBUcHKyUUurGjRvK2tpaLV++XFt/5coVZWdnp4YOHVpgbq1bt1aDBw82agsODlYBAQHact++fVX37t215fv5/v373/9WnTp1MtrPmTNnFKCOHj2a73aVUqply5bq/fffV0op9fnnn6sGDRqozMzMfF9L7dq11dSpU5VSJfOeCiFMR+paDqlrUtfuJHWtdMkZMXHfmjZtqv2/hYUFVatWNfoVxd3dHcDoYttZs2bRokULqlWrhqOjI3PnztV+Tcv1zjvv0KBBA2bOnMmCBQuoWrVqoXl4e3vj5ORktF8/Pz/0er1R2/1c9Hvna3R3d8fe3p46derc13ZfeeUVFi1axF9//cWuXbvo3bt3gbE1atTAwcFBGyP/3//+F2trawDGjRvHxYsXmTNnDo0bN2bOnDk0bNiQP/74o9D9t27dOs9yfHw8APHx8dSsWZOaNWtq6/38/KhcubIWA3nfa09PT+31nzhxgszMTIKDg7X1Li4u+Pr6FppXfHy80XPyyzU/xf3+HTx4kKioKBwdHbVHw4YNtdzz2+7dr7Fnz56kp6dTp04dBg4cyMqVK7l9+3aBr+tB31MhhGlJXZO6JnVN6popSUdM3DcrKyujZZ1OZ9SWO2uSwWAAYNmyZbz77rsMGDCAjRs3EhsbS//+/cnMzDTaTlJSEseOHcPCwoLjx48/cB65bbl55BYydccQiKysrHtu+17bvZeuXbuSnp7OgAEDCA0NLbQQb9++nd9//52UlBRiY2PzHNCrVq1Kz549mTx5MvHx8Xh5eTF58uQi5fEgHuT1myKXwr5/qamphIaGEhsba/Q4fvw47dq1K3S7uduoWbMmR48eZfbs2djZ2TF48GDatWtX4Pfnfl+Hud5TISo6qWtS16SuSV0zJemICZPZuXMnbdq0YfDgwQQGBlKvXj2jX2xyvfLKK/j7+7N48WLef/99o19ZSkK1atUAuHDhgtZ25wXOpcXS0pKXX36ZLVu2FHptAICPjw9169Y1+kWpINbW1tStW/ees0vt3r07z3KjRo0AaNSoEWfOnOHMmTPa+sOHD3Pt2jX8/PzumQNA3bp1sbKyMrpmITk5+Z7TMjdq1CjPdQ5351oSmjdvzqFDh/D29qZevXpGDwcHhyJvx87OjtDQUL744gu2bNnCrl278v3VtiTeUyFE2SZ1TepafqSuiaKyNHcCouKoX78+33zzDRs2bMDHx4dvv/2WPXv2GM2KNGvWLHbt2sXvv/9OzZo1WbduHb1792b37t3aEIYHZWdnxyOPPMKnn36Kj48PSUlJfPzxxyWy7Xv597//TWRk5D2HpRRk7dq1LFu2jOeff54GDRqglGLNmjX89NNPLFy4sNDn7ty5k0mTJtGjRw82bdrEihUrWLduHQAhISH4+/vTu3dvpk2bxu3btxk8eDDt27cnKCioSLk5OjoyYMAA7fW5ubnx0UcfGQ2lyc/QoUPp168fQUFBtG3blqVLl3Lo0CGjoTIlITw8nHnz5vHCCy9os0f9+eefLFu2jK+//hoLC4t7bmPRokVkZ2cTHByMvb09S5Yswc7Ojtq1a+eJLYn3VAhRtkldk7qWH6lroqjkjJgwmddff51nnnmGsLAwgoODuXLlCoMHD9bWHzlyhMjISGbPnq2NP549ezaXL19mxIgRJZrLggULuH37Ni1atCAiIoKxY8eW6PYLYm1tjaurq9HNLovDz88Pe3t73nnnHZo1a8YjjzzC8uXL+frrr+nTp0+hz33nnXfYu3cvgYGBjB07lilTptC5c2cgZ9jA6tWrqVKlCu3atSMkJIQ6derwww8/FCu/zz77jP/7v/8jNDSUkJAQHn30UVq0aFHoc8LCwhgxYgTvvfceLVq04NSpUwwaNKhY+y0KLy8vdu7cSXZ2Np06dcLf35+IiAgqV658z6Kaq3LlysybN4+2bdvStGlTfvnlF9asWZPvHyAl9Z4KIcouqWtS1/IjdU0UlU6pYs4VKoQQQgghhBDigcgZMSGEEEIIIYQwMemICSGEEEIIIYSJSUdMCCGEEEIIIUxMOmJCCCGEEEIIYWLSERNCCCGEEEIIE5OOmBBCCCGEEEKYmHTEhBBCCCGEEMLEpCMmhBBCCCGEECYmHTEhhBBCCCGEMDHpiAkhhBBCCCGEiUlHTAghhBBCCCFMTDpiQgghhBBCCGFi/w8kMkpzJL5qoQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.gridspec as gridspec\n", "\n", From a975567723aad125d5768ee9ac3e9bc3e1382f6c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 4 Nov 2024 10:47:18 +0100 Subject: [PATCH 26/88] fix formatting --- docs/how-to-guides/lucj_mps.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index cd011d5fd..b03fbb956 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -192,8 +192,9 @@ "from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel\n", "\n", "print(\"original Hamiltonian type = \", type(mol_hamiltonian))\n", - "hamiltonian_mpo_model = \\\n", - " MolecularHamiltonianMPOModel.from_molecular_hamiltonian(mol_hamiltonian)\n", + "hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", + " mol_hamiltonian\n", + ")\n", "hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", "print(\"converted Hamiltonian type = \", type(hamiltonian_mpo))\n", "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" @@ -232,9 +233,9 @@ "dp_list = np.arange(1, 16, dtype=int)\n", "chi_list = []\n", "for dp in dp_list:\n", - " hamiltonian_mpo_model = \\\n", - " MolecularHamiltonianMPOModel.from_molecular_hamiltonian(mol_hamiltonian, \n", - " decimal_places=dp)\n", + " hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", + " mol_hamiltonian, decimal_places=dp\n", + " )\n", " hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", " chi_list.append(max(hamiltonian_mpo.chi))\n", "\n", From 7af99aaea2501c4ae962668d1e3ce0a6afd64c73 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 4 Nov 2024 11:01:58 +0100 Subject: [PATCH 27/88] resolve conflict in __init__ file --- python/ffsim/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/python/ffsim/__init__.py b/python/ffsim/__init__.py index 47f164b8f..97919138b 100644 --- a/python/ffsim/__init__.py +++ b/python/ffsim/__init__.py @@ -188,7 +188,6 @@ "slater_determinant_rdms", "spin_square", "strings_to_addresses", - "strings_to_indices", "tenpy", "testing", "trace", From 13fd3077c6fa303d4dc61e82f18ca988a08c9860 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 4 Nov 2024 11:05:33 +0100 Subject: [PATCH 28/88] resolve conflicts --- python/ffsim/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/python/ffsim/__init__.py b/python/ffsim/__init__.py index 97919138b..ec0406343 100644 --- a/python/ffsim/__init__.py +++ b/python/ffsim/__init__.py @@ -83,7 +83,6 @@ slater_determinant_rdms, spin_square, strings_to_addresses, - strings_to_indices, ) from ffsim.trotter import ( simulate_qdrift_double_factorized, From fa520802b268961b7c413ee33cb501f83f7e9ed4 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 4 Nov 2024 17:20:41 +0100 Subject: [PATCH 29/88] start transition from qubit to fermionic gate names --- docs/how-to-guides/lucj_mps.ipynb | 95 ++++++++++- python/ffsim/tenpy/__init__.py | 6 + python/ffsim/tenpy/circuits/gates.py | 175 ++++++++++++++++++++ python/ffsim/tenpy/circuits/lucj_circuit.py | 21 ++- 4 files changed, 279 insertions(+), 18 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index b03fbb956..ee45e18b4 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -33,10 +33,10 @@ "name": "stdout", "output_type": "stream", "text": [ + "converged SCF energy = -77.8266321248745\n", + "Parsing /tmp/tmp7r2dc_fs\n", "converged SCF energy = -77.8266321248744\n", - "Parsing /tmp/tmpkaelgp31\n", - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374029 E_corr = -0.0475832388658529\n" + "E(CCSD) = -77.8742153637403 E_corr = -0.04758323886584406\n" ] }, { @@ -216,7 +216,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGwCAYAAACzXI8XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXkElEQVR4nO3deXxMV/8H8M9MMjPZd7KQhVgSJChF0PKU1BqUoqrE0kWrYmk1PLWWovVoUarVKs/za1VbS+mGUGJX+9JqRIoIIUVkkW2SOb8/0gwji5mYmZuZ+bxfr7xemXtv7v2ecyeZb8459xyZEEKAiIiIyALJpQ6AiIiIqLqYyBAREZHFYiJDREREFouJDBEREVksJjJERERksZjIEBERkcViIkNEREQWy17qAExNo9Hg2rVrcHV1hUwmkzocIiIi0oMQAjk5OQgICIBcXnm7i9UnMteuXUNgYKDUYRAREVE1XLlyBXXr1q10v9UnMq6urgBKK8LNzU3iaIxLrVZj+/btePrpp6FQKKQOx+xYftsuP8A6sPXyA6wDay5/dnY2AgMDtZ/jlbH6RKasO8nNzc0qExknJye4ublZ3RtYHyy/bZcfYB3YevkB1oEtlP9hw0I42JeIiIgsFhMZIiIislhMZIiIiMhiMZEhIiIii8VEhoiIiCwWExkiIiKyWExkiIiIyGIxkSEiIiKLxUSGiIiILBYTGSIiIrJYTGSIiIjIYjGRISIiompJz8rHgZSbSM/KlywGq180koiIiIzvmyOpmLrxDDQCkMuA+f0jMPjxILPHwRYZIiIiMkh6Vr42iQEAjQD+vfGsJC0zTGSIiIjIIF8duqxNYsqUCIFLN/PMHgu7loiIiEgvBeoSzP7hd3z925Vy++xkMoT4OJk9JrbIEBER0UNdyMhFv+X78fVvVyCTAU+F1YZcVrrPTibDvP7N4O/uaPa42CJDREREVdpwLA3Tvj+LfHUJfFyU+HBwCzzRsBbSs/Jx6WYeQnycJEliACYyREREVIm8omLM2Pw71h9LAwBE1ffGkudaoLabAwDA391RsgSmDBMZIiIiKuf8jRyM/eo4kjNyIZcB47s0wutPNYBdWX9SDcFEhoiIiLSEEPjuaBpmbDmLArUGtVxVWPpcS0SFeksdWoWYyBAREREAILewGNM2ncH3J68BAJ5o6IMPB7eAj4tK4sgqJ+lTS7NmzYJMJtP5CgsL0+7v3Llzuf1jxoyRMGIiIiLr9Me1bPT5aB++P3kNdnIZJndrjP+ObFOjkxigBrTING3aFDt27NC+trfXDemll17CO++8o33t5GT+Z9SJiIislRACa39Lxewf/kBRsQZ+bg746PmWeDzES+rQ9CJ5ImNvbw8/P79K9zs5OVW5n4iIiKonp0CNKRvP4KfT6QCAfzWuhUWDWsDLWSlxZPqTPJFJTk5GQEAAHBwcEBUVhfnz5yMo6N6iU1999RW+/PJL+Pn5ISYmBtOnT6+yVaawsBCFhYXa19nZ2QAAtVoNtVptuoJIoKw81lYufbH8tl1+gHVg6+UHWAePUv7fr2Uj7ptTSL2dD3u5DG9EN8So9sGQy2U1oj71jUEmhBAPP8w0fvnlF+Tm5qJx48ZIT0/H7NmzcfXqVZw9exaurq5YuXIlgoODERAQgNOnTyM+Ph5t2rTBxo0bKz3nrFmzMHv27HLb165dy24pIiKyeUIAe6/L8P1lOUqEDJ5KgdhGJajnKnVkuvLy8vD8888jKysLbm5ulR4naSLzoDt37iA4OBgffPABRo8eXW7/r7/+ii5duuDChQsIDQ2t8BwVtcgEBgbi5s2bVVaEJVKr1UhISEB0dDQUCoXU4Zgdy2/b5QdYB7ZefoB1YGj5s/PVmPr979j+RwYAoEtYLSx4phk8nGpe3WVnZ8PHx+ehiYzkXUv38/DwQKNGjXDhwoUK97dt2xYAqkxkVCoVVKryI6wVCoXVvsmtuWz6YPltu/wA68DWyw+wDvQp/8krd/D62uNIy8yHwk6GqT3CMbJDCGSymjXBXRl972eNWjQyNzcXKSkp8Pf3r3D/yZMnAaDS/URERKRLCIHP9/6FZ1ccQFpmPgK9HLF+THuM6livxiYxhpC0RebNN99ETEwMgoODce3aNcycORN2dnYYMmQIUlJSsHbtWvTs2RPe3t44ffo0Jk6ciCeffBKRkZFShk1ERGQR7uQV4c3vTmHHudKupB7N/LBgQCTcHa2n9UrSRCYtLQ1DhgzBrVu3UKtWLXTs2BGHDh1CrVq1UFBQgB07dmDx4sW4e/cuAgMDMWDAAEybNk3KkImIiCzCscu3MW7tCVzLKoDSTo7pvcPxQrtgq2iFuZ+kicy6desq3RcYGIjExEQzRkNERGT5NBqBlXv/wsJtSSjRCIR4O2HZ84+hWR13qUMziRo12JeIiIiq71ZuId747hR2J/0NAIhpHoB5zzSDq4P1dCU9iIkMERGRFTj81y3ErTuBG9mFUNnLMatPUzz3eKDVdSU9qEY9tUSWJT0rHwdSbiI9K1+i6xcgOUuG9KwCia5v2+UvjcG264Dll7b8pTHYdh2kZxUg6Y4MC7aex5DPDuFGdiHq13LG92M7YEibIKtPYoAaNiGeKWRnZ8Pd3f2hE+pYIrVajZ9//hk9e/Y0+/wJ3xxJxdSNZ6ARgFwGvNWtMXo3DzDb9X88dQ3vb0vi9SW6fk2Igde37evXhBhqwvXf25aE+z/F+7esgzn9msFZZfkdLvp+fjORsWBSJTLpWflov+BXWPc7h4jIsshkwIEpT8Hf3VHqUIxC389vy0/ZyOz+TM+uMIlRyGWQy03fjKnRCKg15QPg9c1z/ZoQA69v29evCTHUxOsLAVy6mWc1iYy+mMiQwcqWe7+fnUyGPfH/MssvUHpWPjos+BX3/w7z+ua7fk2Igde37evXhBhq6vVDfGxvcWQO9iWDHEi5ifXHrwIo7RMGSn955vVvZrY/YP7ujpjfP0J7fbkMklzf7p9BdLZW/vtjsNU6YPmlLf/9MdhqHUhd/pqEY2QsmLnHyNwtLEa3xXuQlpmPoW2D8PpTDXDpZh5CfJwk+eVJvZmDb3/ehUE9/4UgH/OvP5+elW/T5QdYByy/tOUHWAdSl9+UOEaGjG7+L+eQlpmPup6OmNozHC4qe0mzf393BzR0F/B3d5Do+o42Xf7SGGy7Dlh+actfGoNt14HU5a8J2LVEetmXfBNfHkoFALz/bCRcrODRPiIisnxMZOihcgrUiN9wGgAwPCoY7UN9JI6IiIioFBMZeqh5P5/D1Tv5CPJyQnz3MKnDISIi0mIiQ1Xac/5vfP3bFQDAwmcjrWK2SCIish5MZKhS2fd1KY1oH4K29b0ljoiIiEgXExmq1Nwf/0B6VgFCvJ3wVvfGUodDRERUDhMZqtCuPzPw7dE0yGTAwoHN4aRklxIREdU8TGSonKw8NaZsLO1SGt2hHh4P8ZI4IiIioooxkaFy3vnxD9zILkR9H2e82Y1dSkREVHMxkSEdO/64gQ3H0yD/p0vJQWEndUhERESVYiJDWnfyijB10xkAwEtP1EerYE+JIyIiIqoaExnSmrXld/ydU4jQWs6YGN1I6nCIiIgeiokMAQC2/X4d35+8BrkMWDSoBbuUiIjIIjCRIdy+W4S3/+lSeqVTKFoEekgbEBERkZ6YyBBmbvkdN3OL0MjXBRO6NpQ6HCIiIr0xkbFxv5xJxw+nrsFOLsN/BjaHyp5dSkREZDmYyNiwW7mFmPb9WQDAa51DEVnXQ9qAiIiIDMRExobN2Pw7bt0tQpifK8Y9xS4lIiKyPExkbNSPp6/hpzPpsP+nS0lpz7cCERFZHn562aC/cwox/Z8upbH/aoBmddwljoiIiKh6mMjYGCEEpn1/Bpl5ajTxd8PYfzWQOiQiIqJqYyJjY7acuoZtv99glxIREVkFforZkIzsAszY/DsAIK5LQzQJcJM4IiIiokfDRMZGCCHw701nkJWvRrM6bni1c6jUIRERET0yJjI2YtOJq9hxLgMKOxkWDWwBhR1vPRERWT5+mtmAG9kFmLWltEtpQtdGaOznKnFERERExsFExsoJITB14xlkFxQjsq47XnmyvtQhERERGQ0TGSu3/lgafv0zA0o7ORYNbA57dikREZEV4aeaFUvPysc7P/wBAJj0dCM09GWXEhERWRcmMlZKCIEpG84gp7AYLYM88NIT7FIiIiLrw0TGSn179AoSz/8Npb0cC59tDju5TOqQiIiIjM7gRObGjRsYNmwYAgICYG9vDzs7O50vkt7VO/mY8+M5AMDkpxujQW0XiSMiIiIyDXtDf2DEiBFITU3F9OnT4e/vD5mM/+nXJEIIxK8/jdzCYrQK9sSojvWkDomIiMhkDE5k9u3bh71796JFixYmCIce1drfUrHvwk04KORY+Gwku5SIiMiqGdy1FBgYCCGEKWKhR3Tldh7m/fRPl1K3MNSvxS4lIiKybgYnMosXL8aUKVNw6dIlE4RD1aXRCMRvOI27RSVoE+KFke1DpA6JiIjI5AzuWho8eDDy8vIQGhoKJycnKBQKnf23b982WnCkv68OX8aBlFtwVNjh/WcjIWeXEhER2QCDE5nFixebIAx6FKm38zDv5z8BAFN6hCHEx1niiIiIiMzD4EQmNjbWFHFQNWkEMHXT78hXl6BdfS8MaxcsdUhERERmU60J8UpKSrBhwwbMnTsXc+fOxaZNm1BSUmLweWbNmgWZTKbzFRYWpt1fUFCAsWPHwtvbGy4uLhgwYABu3LhRnZCt1r7rMvx2KRNOSju8P6A5u5SIiMimGNwic+HCBfTs2RNXr15F48aNAQDz589HYGAgfvrpJ4SGhhp0vqZNm2LHjh33ArK/F9LEiRPx008/4bvvvoO7uztef/119O/fH/v37zc0bKt09FImvr9cmotO7RmOIG8niSMiIiIyL4MTmbi4OISGhuLQoUPw8vICANy6dQsvvPAC4uLi8NNPPxkWgL09/Pz8ym3PysrCqlWrsHbtWjz11FMAgNWrVyM8PByHDh1Cu3btDA3dqnz9WyqmbjwDoLQFxp4tMUREZIMMTmQSExN1khgA8Pb2xoIFC9ChQweDA0hOTkZAQAAcHBwQFRWF+fPnIygoCMeOHYNarUbXrl21x4aFhSEoKAgHDx6sNJEpLCxEYWGh9nV2djYAQK1WQ61WGxxfTZSeVYB/bzyjs+3tTWfQob4n/N0dJIrK/Mrup7XcV0PZevkB1oGtlx9gHVhz+fUtk8GJjEqlQk5OTrntubm5UCqVBp2rbdu2WLNmDRo3boz09HTMnj0bTzzxBM6ePYvr169DqVTCw8ND52d8fX1x/fr1Ss85f/58zJ49u9z27du3w8nJOrpekrNkENBd10ojgG9/3oWG7rY3WWFCQoLUIUjK1ssPsA5svfwA68Aay5+Xl6fXcQYnMr1798bLL7+MVatWoU2bNgCAw4cPY8yYMejTp49B5+rRo4f2+8jISLRt2xbBwcH49ttv4ejoaGhoAICpU6di0qRJ2tfZ2dkIDAzE008/DTc3t2qds6ZJzyrAsj/26GyTy4BBPf9lcy0yCQkJiI6OLjefkS2w9fIDrANbLz/AOrDm8pf1qDyMwYnM0qVLERsbi6ioKG2lFRcXo0+fPliyZImhp9Ph4eGBRo0a4cKFC4iOjkZRURHu3Lmj0ypz48aNCsfUlFGpVFCpVOW2KxQKq7nJQT4K1HZVISOntAtNLgPm949AkI+rxJFJw5rubXXYevkB1oGtlx9gHVhj+fUtj8GJjIeHBzZv3ozk5GT8+WfpJGzh4eFo0KCBoacqJzc3FykpKRg2bBhatWoFhUKBnTt3YsCAAQCApKQkpKamIioq6pGvZcmEEMguKO07fCG0BC8/8y+bTWKIiMi2GZzIlGnYsCEaNmz4SBd/8803ERMTg+DgYFy7dg0zZ86EnZ0dhgwZAnd3d4wePRqTJk2Cl5cX3NzcMG7cOERFRdn8E0u37xahQK0BALTwETbVnURERHQ/vRKZSZMmYc6cOXB2dtYZf1KRDz74QO+Lp6WlYciQIbh16xZq1aqFjh074tChQ6hVqxYA4MMPP4RcLseAAQNQWFiIbt264eOPP9b7/Nbq6p18AEBtVxUU8mKJoyEiIpKOXonMiRMntI9BnThxotLjZDLD5jJZt25dlfsdHBywfPlyLF++3KDzWrurmaWJTICHA4C70gZDREQkIb0SmV27dlX4PUmjrEWmjnv1nuwiIiKyFtVaa+l+2dnZ+P7777UDf8n00nRaZIiIiGyXwYnMoEGDsGzZMgBAfn4+WrdujUGDBiEiIgIbNmwweoBUXlkiU8eTLTJERGTbDE5k9uzZgyeeeAIAsGnTJgghcOfOHSxduhRz5841eoBUnrZriS0yRERk4wxOZLKysrTrLG3duhUDBgyAk5MTevXqheTkZKMHSOVdzSydtpljZIiIyNYZnMgEBgbi4MGDuHv3LrZu3Yqnn34aAJCZmQkHB7YQmFp2gRrZBaWPXHOMDBER2TqDJ8SbMGEChg4dChcXFwQHB6Nz584ASrucIiIijB0fPaDs0WsPJwWcVdWez5CIiMgqGPxJ+Nprr6FNmza4cuUKoqOjIZeXNurUr1+fY2TMoCyRqcuBvkRERNVboqB169Zo3bq1zrZevXoZJSCq2r2BvkxkiIiIDE5kSkpKsGbNGuzcuRMZGRnQaDQ6+3/99VejBUflpZUN9PVwkjgSIiIi6RmcyIwfPx5r1qxBr1690KxZM4OXJaBHo22RYdcSERGR4YnMunXr8O2336Jnz56miIcegmNkiIiI7jH48WulUokGDRqYIhbSA8fIEBER3WNwIvPGG29gyZIlEEKYIh6qQoG6BDdziwCwRYaIiAioRtfSvn37sGvXLvzyyy9o2rQpFAqFzv6NGzcaLTjSVbbGkrPSDu6OChQXF0scERERkbQMTmQ8PDzwzDPPmCIWeoiybqW6nk4cZE1ERIRqJDKrV682RRykh6tc9ZqIiEiHwWNkAKC4uBg7duzAp59+ipycHADAtWvXkJuba9TgSNfVO2VzyDCRISIiAqrRInP58mV0794dqampKCwsRHR0NFxdXfHee++hsLAQn3zyiSniJNwbI8MWGSIiolIGt8iMHz8erVu3RmZmJhwd732gPvPMM9i5c6dRgyNdnEOGiIhIl8EtMnv37sWBAwegVCp1toeEhODq1atGC4zK4xwyREREugxukdFoNCgpKSm3PS0tDa6urkYJisorKtbgRnYBAHYtERERlTE4kXn66aexePFi7WuZTIbc3FzMnDmTyxaY0PWsAmgEoLSXw8dZJXU4RERENYLBXUuLFi1Ct27d0KRJExQUFOD5559HcnIyfHx88PXXX5siRgKQdt8TS3I555AhIiICqpHI1K1bF6dOncK6detw+vRp5ObmYvTo0Rg6dKjO4F8yLg70JSIiKs/gRAYA7O3t8cILLxg7FqoCB/oSERGVV61E5tq1a9i3bx8yMjKg0Wh09sXFxRklMNKlndWXiQwREZGWwYnMmjVr8Morr0CpVMLb21tnzR+ZTMZExkQ4GR4REVF5Bicy06dPx4wZMzB16lTI5dVa4YCq4f4FI4mIiKiUwZlIXl4ennvuOSYxZqTRCKRnsUWGiIjoQQZnI6NHj8Z3331nilioEhk5hVCXCNjJZfB15RwyREREZQzuWpo/fz569+6NrVu3IiIiAgqFQmf/Bx98YLTgqFRaZukcMn5uDrC3Y0sYERFRmWolMtu2bUPjxo0BoNxgXzK+e+Nj2K1ERER0v2rN7PvFF19gxIgRJgiHKsInloiIiCpmcD+FSqVChw4dTBELVULbIsM5ZIiIiHQYnMiMHz8eH330kSlioUqwRYaIiKhiBnct/fbbb/j111/x448/omnTpuUG+27cuNFowVGpq5llC0ZyDhkiIqL7GZzIeHh4oH///qaIhSoghOBgXyIiokoYnMisXr3aFHFQJW7fLUKBunQ9K38PB4mjISIiqlk4KUkNV9YaU9tVBZW9ncTREBER1Sx6tcg89thj2LlzJzw9PdGyZcsq54s5fvy40YIjDvQlIiKqil6JTN++faFSlU6N369fP1PGQw+4msnFIomIiCqjVyIzc+bMCr8n0yvrWqrDOWSIiIjK4RiZGo5dS0RERJXTq0XG09NT73WUbt++/UgBka6yBSM5qy8REVF5eiUyixcv1n5/69YtzJ07F926dUNUVBQA4ODBg9i2bRumT59ukiBtGeeQISIiqpxeiUxsbKz2+wEDBuCdd97B66+/rt0WFxeHZcuWYceOHZg4caLxo7RR2QVq5BQUA2DXEhERUUUMHiOzbds2dO/evdz27t27Y8eOHUYJikqVPbHk6aSAk9LguQuJiIisnsGJjLe3NzZv3lxu++bNm+Ht7W2UoKgUB/oSERFVzeBEZvbs2YiPj0dMTAzmzp2LuXPnIiYmBlOmTMHs2bOrHciCBQsgk8kwYcIE7bbOnTtDJpPpfI0ZM6ba17A0V7UDfTmHDBERUUUM7q8YMWIEwsPDsXTpUu1K1+Hh4di3bx/atm1brSCOHDmCTz/9FJGRkeX2vfTSS3jnnXe0r52cbOdDXTuHDFtkiIiIKlStgRdt27bFV199ZZQAcnNzMXToUHz22WeYO3duuf1OTk7w8/MzyrUsDSfDIyIiqprkI0jHjh2LXr16oWvXrhUmMl999RW+/PJL+Pn5ISYmBtOnT6+yVaawsBCFhYXa19nZ2QAAtVoNtVpt/AKYUNrt0q4lP1dlhbGXbbO0chkLy2/b5QdYB7ZefoB1YM3l17dMkiYy69atw/Hjx3HkyJEK9z///PMIDg5GQEAATp8+jfj4eCQlJWm7tCoyf/78CsfqbN++3eK6pf66YQdAhou/H8XPlyo/LiEhwVwh1Ugsv22XH2Ad2Hr5AdaBNZY/Ly9Pr+NkQghh4lgqdOXKFbRu3RoJCQnasTGdO3dGixYtdCbgu9+vv/6KLl264MKFCwgNDa3wmIpaZAIDA3Hz5k24ubkZvRymkl9Ugsg5OwEAR//9L7g7Ksodo1arkZCQgOjoaCgU5fdbO5bftssPsA5svfwA68Cay5+dnQ0fHx9kZWVV+fktWYvMsWPHkJGRgccee0y7raSkBHv27MGyZctQWFgIOzs7nZ8pG0xcVSKjUqm0K3XfT6FQWNRNvpxZmoy5qOzh7epY5RIRllY2Y2P5bbv8AOvA1ssPsA6ssfz6lkeyRKZLly44c+aMzraRI0ciLCwM8fHx5ZIYADh58iQAwN/f3xwhSur+gb76rnNFRERka/RKZPr376/3Casav3I/V1dXNGvWTGebs7MzvL290axZM6SkpGDt2rXo2bMnvL29cfr0aUycOBFPPvlkhY9pW5uyxSL56DUREVHl9Epk3N3dtd8LIbBp0ya4u7ujdevWAEq7ie7cuWNQwvMwSqUSO3bswOLFi3H37l0EBgZiwIABmDZtmtGuUZOVLU/AxSKJiIgqp1cis3r1au338fHxGDRoED755BNt909JSQlee+21Rx5Mu3v3bu33gYGBSExMfKTzWTLOIUNERPRwBi9R8MUXX+DNN9/UGcNiZ2eHSZMm4YsvvjBqcLbsKtdZIiIieiiDE5ni4mL8+eef5bb/+eef0Gg0RgmK7lswki0yRERElTL4qaWRI0di9OjRSElJQZs2bQAAhw8fxoIFCzBy5EijB2iLioo1uJFTAACo62lZk/gRERGZk8GJzH/+8x/4+flh0aJFSE9PB1D6OPTkyZPxxhtvGD1AW3Q9qwBCACp7OXxclFKHQ0REVGMZnMjI5XK89dZbeOutt7TrGFnSjLmWIO3OP49ecw4ZIiKiKj3ShHhMYEyDA32JiIj0Y/Bg3xs3bmDYsGEICAiAvb097OzsdL7o0XGgLxERkX4MbpEZMWIEUlNTMX36dPj7+7PrwwTK5pDhZHhERERVMziR2bdvH/bu3YsWLVqYIBwC2LVERESkL4O7lgIDAyGEMEUs9I97s/ry0WsiIqKqGJzILF68GFOmTMGlS5dMEA6VaASu3WGLDBERkT4M7loaPHgw8vLyEBoaCicnJygUCp39t2/fNlpwtigjpwDFGgF7uQy+riqpwyEiIqrRDE5kFi9ebIIwqEzZ+Bg/dwfY2xncYEZERGRTDE5kYmNjTREH/YOrXhMREemvWhPilZSU4Pvvv8e5c+cAAE2bNkWfPn04j4wRpPGJJSIiIr0ZnMhcuHABPXv2xNWrV9G4cWMAwPz58xEYGIiffvoJoaGhRg/SlpQlMlwskoiI6OEMHoQRFxeH0NBQXLlyBcePH8fx48eRmpqKevXqIS4uzhQx2hTtZHjsWiIiInoog1tkEhMTcejQIXh5eWm3eXt7Y8GCBejQoYNRg7NFVzP/WTCSXUtEREQPZXCLjEqlQk5OTrntubm5UCqVRgnKVgkhONiXiIjIAAYnMr1798bLL7+Mw4cPQwgBIQQOHTqEMWPGoE+fPqaI0WbculuEArUGAODv4SBxNERERDWfwYnM0qVLERoaiqioKDg4OMDBwQEdOnRAgwYNsGTJElPEaDPK5pDxdVNBZc8nwIiIiB7G4DEyHh4e2Lx5M5KTk3Hu3DnIZDKEh4ejQYMGpojPprBbiYiIyDDVmkcGABo2bKhNXmQymdECsmX3Vr3mo9dERET6qNYc+KtWrUKzZs20XUvNmjXD559/buzYbE5a2RNLbJEhIiLSi8EtMjNmzMAHH3yAcePGISoqCgBw8OBBTJw4EampqXjnnXeMHqSt0M4hw0eviYiI9GJwIrNixQp89tlnGDJkiHZbnz59EBkZiXHjxjGReQRcnoCIiMgwBnctqdVqtG7dutz2Vq1aobi42ChB2SrO6ktERGQYgxOZYcOGYcWKFeW2r1y5EkOHDjVKULYoK1+NnILSRJAtMkRERPrRq2tp0qRJ2u9lMhk+//xzbN++He3atQMAHD58GKmpqRg+fLhporQBZU8seTkr4aSs9sNkRERENkWvT8wTJ07ovG7VqhUAICUlBQDg4+MDHx8f/P7770YOz3ZwDhkiIiLD6ZXI7Nq1y9Rx2LyrfPSaiIjIYNWaR4aMT9siw/ExREREemMiU0OUPXrNOWSIiIj0x0SmhuAYGSIiIsMxkakhrnIyPCIiIoMxkakB8otKcOtuEQCgrgcXjCQiItKXwYnMd999h/79+6NZs2Zo1qwZ+vfvj/Xr15siNptx9U7pE0suKnu4OXIOGSIiIn3pnchoNBoMHjwYgwcPxh9//IEGDRqgQYMG+P333zF48GA899xzEEKYMlardf9AX5lMJnE0RERElkPvf/+XLFmCHTt2YMuWLejdu7fOvi1btmDkyJFYsmQJJkyYYOwYrR4H+hIREVWP3i0yq1evxsKFC8slMUDp6tfvv/8+vvjiC6MGZys40JeIiKh69E5kkpOT0bVr10r3d+3aFcnJyUYJytawRYaIiKh69E5kHB0dcefOnUr3Z2dnw8HBwRgx2Zx7Y2T4xBIREZEh9E5koqKisGLFikr3L1++HFFRUUYJytawa4mIiKh69B7s+/bbb6Nz5864desW3nzzTYSFhUEIgXPnzmHRokXYvHkzF5eshqJiDW7kFABg1xIREZGh9E5k2rdvj2+++QYvv/wyNmzYoLPP09MTX3/9NTp06GD0AK3d9awCCAGo7OXwcVFKHQ4REZFFMWj2tWeeeQbdunXDtm3btAN7GzVqhKeffhpOThzfUR1pmaWT4dXhHDJEREQGMyiREULg6tWraNSoEWJiYmBvz1loH1Uan1giIiKqNr0H+168eBGRkZEICwtDZGQkQkNDcfToUVPGZhOu3jerLxERERlG70Rm8uTJKC4uxpdffon169ejbt26ePnll00Zm03gHDJERETVp3cis2/fPnz22WcYMmQInnnmGaxfvx6nTp3C3bt3jRLIggULIJPJdJY4KCgowNixY+Ht7Q0XFxcMGDAAN27cMMr1aor7x8gQERGRYfROZDIyMtCwYUPta39/fzg6OiIjI+ORgzhy5Ag+/fRTREZG6myfOHEifvjhB3z33XdITEzEtWvX0L9//0e+Xk1S1iLDyfCIiIgMp3ciI5PJkJubi+zsbO2XXC5HTk6OzjZD5ebmYujQofjss8/g6emp3Z6VlYVVq1bhgw8+wFNPPYVWrVph9erVOHDgAA4dOmTwdWqiEo1A+h3OIUNERFRdej92JIRAo0aNym1r2bKl9nuZTIaSkhKDAhg7dix69eqFrl27Yu7cudrtx44dg1qt1lnfKSwsDEFBQTh48CDatWtX4fkKCwtRWFiofV2WXKnVaqjVaoNiM7X0rAIUawTs5TJ4OdoZHF/Z8TWtXObC8tt2+QHWga2XH2AdWHP59S2T3omMKWbtXbduHY4fP44jR46U23f9+nUolUp4eHjobPf19cX169crPef8+fMxe/bsctu3b99e4+a6+SsbAOzhptBg29Zfqn2ehIQEo8VkiVh+2y4/wDqw9fIDrANrLH9eXp5ex+mdyHTq1KnawVTkypUrGD9+PBISEoy62OTUqVMxadIk7evs7GwEBgbi6aefhpubm9GuYwybT6UDv59BwwAv9Oz5uME/r1arkZCQgOjoaCgUChNEWLOx/LZdfoB1YOvlB1gH1lx+fYerSDaj3bFjx5CRkYHHHntMu62kpAR79uzBsmXLsG3bNhQVFeHOnTs6rTI3btyAn59fpedVqVRQqVTltisUihp3k2/kFAEA6no6P1JsNbFs5sTy23b5AdaBrZcfYB1YY/n1LY/eiYydnZ1ex+k7RqZLly44c+aMzraRI0ciLCwM8fHxCAwMhEKhwM6dOzFgwAAAQFJSElJTU61mle00rnpNRET0SAwa7BscHIzY2FjtAN9H4erqimbNmulsc3Z2hre3t3b76NGjMWnSJHh5ecHNzQ3jxo1DVFRUpQN9LY320Ws+sURERFQteicyv/32G1atWoUlS5agXr16GDVqFIYOHarzyLSxffjhh5DL5RgwYAAKCwvRrVs3fPzxxya7nrmVTYbH5QmIiIiqR+95ZFq3bo0VK1YgPT0dkyZNwqZNm1C3bl0899xzRhstvXv3bixevFj72sHBAcuXL8ft27dx9+5dbNy4scrxMZZECIFrd9i1RERE9Cj0TmTKODg44IUXXsDOnTtx9uxZZGRkoHv37rh9+7Yp4rNat+4WoUCtgUwG+LszkSEiIqqOaj21lJaWhjVr1mDNmjXIy8vD5MmTa9yjzTVd2arXtV1VUNobnE8SERERDEhkioqKsGnTJqxatQp79+5Fjx49sHjxYvTo0UPvJ5ronrInlrjGEhERUfXpncj4+/vD1dUVsbGx+Pjjj1G7dm0AKLf6NVtm9HP1zj+rXvOJJSIiomrTO5HJzMxEZmYm5syZo7MmUpnqrrVkq65yDhkiIqJHJulaS7asbA4ZtsgQERFVn2RrLdk6zupLRET06Pi4jETKupYCmcgQERFVGxMZCWTlq5FTWAwACGDXEhERUbUxkZFAWWuMl7MSTkrJFiAnIiKyeExkJMCBvkRERMbBREYCXCySiIjIOAzu1ygoKMBHH32EXbt2ISMjAxqNRmf/8ePHjRactdLOIcMWGSIiokdicCIzevRobN++Hc8++yzatGkDmUxmiris2lWuek1ERGQUBicyP/74I37++Wd06NDBFPHYBI6RISIiMg6Dx8jUqVMHrq6upojFZnDBSCIiIuMwOJFZtGgR4uPjcfnyZVPEY/Xyiopx+24RAHYtERERPSqDu5Zat26NgoIC1K9fH05OTlAoFDr7b9++bbTgrNG1f7qVXFX2cHdUPORoIiIiqorBicyQIUNw9epVzJs3D76+vhzsayCusURERGQ8BicyBw4cwMGDB9G8eXNTxGP1ONCXiIjIeAweIxMWFob8/HxTxGIT7g30ZSJDRET0qAxOZBYsWIA33ngDu3fvxq1bt5Cdna3zRVW7yq4lIiIiozG4a6l79+4AgC5duuhsF0JAJpOhpKTEOJFZqXtdS3z0moiI6FEZnMjs2rXLFHHYDLbIEBERGY/BiUynTp1MEYdNKCrW4EZOAQCOkSEiIjIGgxOZPXv2VLn/ySefrHYw1i49Kx9CAA4KObydlVKHQ0REZPEMTmQ6d+5cbtv9c8lwjEzlyrqVAjwcOf8OERGRERj81FJmZqbOV0ZGBrZu3YrHH38c27dvN0WMViONc8gQEREZlcEtMu7u7uW2RUdHQ6lUYtKkSTh27JhRArNGXCySiIjIuAxukamMr68vkpKSjHU6q3SVk+EREREZlcEtMqdPn9Z5LYRAeno6FixYgBYtWhgrLqt09U4eAHYtERERGYvBiUyLFi0gk8kghNDZ3q5dO3zxxRdGC8waaSfDY4sMERGRURicyFy8eFHntVwuR61ateDg4GC0oKxRiUYg/U7pHDJskSEiIjIOgxOZ4OBgU8Rh9W5kF6BYI2Avl8HXjUkfERGRMRicyADAkSNHsGvXLmRkZECj0ejs++CDD4wSmLUp61by93CAnZxzyBARERmDwYnMvHnzMG3aNDRu3Bi+vr46E7txkrfKaddYYrcSERGR0RicyCxZsgRffPEFRowYYYJwrBdXvSYiIjI+g+eRkcvl6NChgylisWppmaWPXnMOGSIiIuMxOJGZOHEili9fbopYrFrZrL589JqIiMh4DO5aevPNN9GrVy+EhoaiSZMmUCgUOvs3btxotOCsSVnXUl2OkSEiIjIagxOZuLg47Nq1C//617/g7e3NAb56EELcG+zLFhkiIiKjMTiR+e9//4sNGzagV69epojHKt3MLUJhsQYyGeDvzkSGiIjIWAweI+Pl5YXQ0FBTxGK1yrqVfF0doLQ32jqdRERENs/gT9VZs2Zh5syZyMvLM0U8VondSkRERKZhcNfS0qVLkZKSAl9fX4SEhJQb7Hv8+HGjBWctuOo1ERGRaRicyPTr188EYVi3shYZziFDRERkXAYnMjNnzjRFHFaNc8gQERGZBkeemsG95QmYyBARERmTXi0yXl5eOH/+PHx8fODp6Vnl3DG3b982WnDWgl1LREREpqFXIvPhhx/C1dVV+72xJsFbsWIFVqxYgUuXLgEAmjZtihkzZqBHjx4AgM6dOyMxMVHnZ1555RV88sknRrm+OWTlq5FTWAwACGCLDBERkVHplcjExsZqvzfmqtd169bFggUL0LBhQwgh8N///hd9+/bFiRMn0LRpUwDASy+9hHfeeUf7M05OlrV6dNlikd7OSjgpDR6SRERERFUweIzMmjVrKtxeXFyMqVOnGnSumJgY9OzZEw0bNkSjRo3w7rvvwsXFBYcOHdIe4+TkBD8/P+2Xm5uboSFLinPIEBERmU611lr66aefsHLlSnh6egIAkpKS8Pzzz+PWrVuYP39+tQIpKSnBd999h7t37yIqKkq7/auvvsKXX34JPz8/xMTEYPr06VW2yhQWFqKwsFD7Ojs7GwCgVquhVqurFdujSL2VCwDwd1MZ/fpl55OiXDUBy2/b5QdYB7ZefoB1YM3l17dMMiGEMOTEKSkpeOGFF3DlyhWsXr0a58+fx1tvvYV+/frh448/hru7u0GBnjlzBlFRUSgoKICLiwvWrl2Lnj17AgBWrlyJ4OBgBAQE4PTp04iPj0ebNm2qXGF71qxZmD17drnta9eulaRbatMlOXany9HZX4NnQjRmvz4REZElysvLw/PPP4+srKwqe2MMTmQAQKPRYMKECVi+fDns7Ozw3//+F0OGDKlWoEVFRUhNTUVWVhbWr1+Pzz//HImJiWjSpEm5Y3/99Vd06dIFFy5cqHS9p4paZAIDA3Hz5k1JuqXGfn0S2//IwPReYRjeLsio51ar1UhISEB0dHS5GZZtActv2+UHWAe2Xn6AdWDN5c/OzoaPj89DE5lqjT796aefsG7dOkRFReH8+fNYtWoVOnXqhICAAIPPpVQq0aBBAwBAq1atcOTIESxZsgSffvppuWPbtm0LAFUmMiqVCiqVqtx2hUIhyU1OzypNqoK8XUx2fanKVlOw/LZdfoB1YOvlB1gH1lh+fctj8GDfV155BQMHDkR8fDz27t2L06dPQ6lUIiIiAt9++63BgT5Io9HotKjc7+TJkwAAf3//R76OuXAyPCIiItMxuEVm//79OHz4MJo3bw4A8PPzw88//4zly5dj1KhRGDRokN7nmjp1Knr06IGgoCDk5ORg7dq12L17N7Zt24aUlBTteBlvb2+cPn0aEydOxJNPPonIyEhDw5ZEXlExbt8tAsCnloiIiEzB4ETm2LFjFXbdjB07Fl27djXoXBkZGRg+fDjS09Ph7u6OyMhIbNu2DdHR0bhy5Qp27NiBxYsX4+7duwgMDMSAAQMwbdo0Q0OWzLV/WmNcHezh7mhdTX5EREQ1gcGJTEVJTJnGjRsbdK5Vq1ZVui8wMLDcrL6W5komu5WIiIhMqVqDfdevX49vv/0WqampKCoq0tl3/PhxowRmDbjGEhERkWkZPNh36dKlGDlyJHx9fXHixAm0adMG3t7e+Ouvv7RrJFEpDvQlIiIyLYMTmY8//hgrV67ERx99BKVSibfeegsJCQmIi4tDVlaWKWK0WFyegIiIyLQMTmRSU1PRvn17AICjoyNycnIAAMOGDcPXX39t3OgsXNmCkXU9LWuhSyIiIkthcCLj5+eH27dvAwCCgoK0CzxevHgR1Zgk2Kqxa4mIiMi0DE5knnrqKWzZsgUAMHLkSEycOBHR0dEYPHgwnnnmGaMHaKmKijXIyCmd2I9dS0RERKZh8FNLK1euhEZTuvjh2LFj4e3tjQMHDqBPnz545ZVXjB6gpUrPyocQgINCDm9npdThEBERWSWDExm5XA65/F5DznPPPYfnnnvOqEFZg7T75pCRyWQSR0NERGSdqjWPTEFBAU6fPo2MjAxt60yZPn36GCUwS3fviSUO9CUiIjIVgxOZrVu3Yvjw4bh582a5fTKZDCUlJUYJzNKlcaAvERGRyRk82HfcuHEYOHAg0tPTodFodL6YxNzDWX2JiIhMz+BE5saNG5g0aRJ8fX1NEY/VuHqnbA4ZJjJERESmYnAi8+yzz2L37t0mCMW6pHHBSCIiIpMzeIzMsmXLMHDgQOzduxcRERFQKBQ6++Pi4owWnKUq0QhczyoAwDlkiIiITMngRObrr7/G9u3b4eDggN27d+s8WiyTyZjIALiRXYBijYC9XIbarg5Sh0NERGS1DE5k3n77bcyePRtTpkzRmU+G7ilbmiDAwxF2cs4hQ0REZCoGZyJFRUUYPHgwk5gqlC0WyfExREREpmVwNhIbG4tvvvnGFLFYjXuT4TGRISIiMiWDu5ZKSkrw/vvvY9u2bYiMjCw32PeDDz4wWnCWiqteExERmYfBicyZM2fQsmVLAMDZs2d19nFNoVJpbJEhIiIyC4MTmV27dpkiDqvCWX2JiIjMgyN2jUwIoe1aquvBBSOJiIhMiYmMkd3MLUJhsQYyGeDnzjlkiIiITImJjJGVtcb4ujpAac/qJSIiMiV+0hoZx8cQERGZDxMZI9NOhsdEhoiIyOSYyBgZ55AhIiIyHyYyRsZZfYmIiMyHiYyRaR+99uSj10RERKbGRMaIhBD3ZvVl1xIREZHJMZExouz8YuQWFgNgIkNERGQOTGSMKO1O6RNL3s5KOCrtJI6GiIjI+jGRMSIO9CUiIjIvJjJGlMbJ8IiIiMyKiYwRcQ4ZIiIi82IiY0RX+cQSERGRWTGRMSJtiwznkCEiIjILJjJGdG8yPLbIEBERmQMTGSPJKyrG7btFAPjUEhERkbkwkTGSsvExrg72cHNQSBwNERGRbWAiYyRpfGKJiIjI7JjIGMnVTC4WSUREZG5MZIyEk+ERERGZHxMZI+FkeERERObHRMZIrmaWLhjJJ5aIiIjMh4mMkbBFhoiIyPyYyBhBYXEJMnIKAXCMDBERkTkxkTGC9DsFEAJwUMjh5ayUOhwiIiKbwUTGCO7vVpLJZBJHQ0REZDskTWRWrFiByMhIuLm5wc3NDVFRUfjll1+0+wsKCjB27Fh4e3vDxcUFAwYMwI0bNySMuGLaVa85hwwREZFZSZrI1K1bFwsWLMCxY8dw9OhRPPXUU+jbty9+//13AMDEiRPxww8/4LvvvkNiYiKuXbuG/v37SxlyhdK4WCQREZEk7KW8eExMjM7rd999FytWrMChQ4dQt25drFq1CmvXrsVTTz0FAFi9ejXCw8Nx6NAhtGvXToqQK5RW9ug1n1giIiIyK0kTmfuVlJTgu+++w927dxEVFYVjx45BrVaja9eu2mPCwsIQFBSEgwcPVprIFBYWorCwUPs6OzsbAKBWq6FWq00Se9rt0kTGz1VpsmtUpOxa5rxmTcLy23b5AdaBrZcfYB1Yc/n1LZPkicyZM2cQFRWFgoICuLi4YNOmTWjSpAlOnjwJpVIJDw8PneN9fX1x/fr1Ss83f/58zJ49u9z27du3w8nJNGNYLqTbAZAh9dwJ/Hz1hEmuUZWEhASzX7MmYfltu/wA68DWyw+wDqyx/Hl5eXodJ3ki07hxY5w8eRJZWVlYv349YmNjkZiYWO3zTZ06FZMmTdK+zs7ORmBgIJ5++mm4ubkZI2QdxSUavHF4JwCBZ3s+BT83B6NfozJqtRoJCQmIjo6GQqEw23VrCpbftssPsA5svfwA68Cay1/Wo/IwkicySqUSDRo0AAC0atUKR44cwZIlSzB48GAUFRXhzp07Oq0yN27cgJ+fX6XnU6lUUKlU5bYrFAqT3OSMu/ko1ggo7GSo4+kCudz8j1+bqmyWguW37fIDrANbLz/AOrDG8utbnho3j4xGo0FhYSFatWoFhUKBnTt3avclJSUhNTUVUVFREkaoq+zRa393R0mSGCIiIlsmaYvM1KlT0aNHDwQFBSEnJwdr167F7t27sW3bNri7u2P06NGYNGkSvLy84ObmhnHjxiEqKqpGPbF09Q6fWCIiIpKKpIlMRkYGhg8fjvT0dLi7uyMyMhLbtm1DdHQ0AODDDz+EXC7HgAEDUFhYiG7duuHjjz+WMuRyylpkOIcMERGR+UmayKxatarK/Q4ODli+fDmWL19upogMp12egIkMERGR2dW4MTKWJi3z3jpLREREZF5MZB7RvXWWmMgQERGZGxOZRyCE0HYt1fXggpFERETmxkTmEdzMLUJhsQZyGeDnbr6J8IiIiKgUE5lHULZYpK+bA5T2rEoiIiJz46fvI9A+scSBvkRERJJgIvMIONCXiIhIWkxkHoF2oC8TGSIiIkkwkXkE9+aQ4RNLREREUmAi8wjYtURERCQtJjLVdP8cMhzsS0REJA0mMtWUnV+M3MJiABwjQ0REJBUmMtWUdqd0DhkfFyUcFHYSR0NERGSbmMhUExeLJCIikh4TmWo6dy0bAODlopQ4EiIiItvFRKYavjmSiiU7kwEAu//8G98cSZU4IiIiItvERMZA6Vn5mLrxDMQ/rwWAf288i/SsfCnDIiIisklMZAx08eZdaITuthIhcOlmnjQBERER2TAmMgaq5+MMuUx3m51MhhAfzu5LRERkbkxkDOTv7oj5/SNgJyvNZuxkMszr3wz+7nx6iYiIyNzspQ7AEg1+PAhPNqqFSzfzEOLjxCSGiIhIIkxkqsnf3ZEJDBERkcTYtUREREQWi4kMERERWSwmMkRERGSxmMgQERGRxWIiQ0RERBaLiQwRERFZLCYyREREZLGYyBAREZHFYiJDREREFouJDBEREVksJjJERERksax+rSUhBAAgOztb4kiMT61WIy8vD9nZ2VAoFFKHY3Ysv22XH2Ad2Hr5AdaBNZe/7HO77HO8MlafyOTk5AAAAgMDJY6EiIiIDJWTkwN3d/dK98vEw1IdC6fRaHDt2jW4urpCJpNJHY5RZWdnIzAwEFeuXIGbm5vU4Zgdy2/b5QdYB7ZefoB1YM3lF0IgJycHAQEBkMsrHwlj9S0ycrkcdevWlToMk3Jzc7O6N7AhWH7bLj/AOrD18gOsA2stf1UtMWU42JeIiIgsFhMZIiIislhMZCyYSqXCzJkzoVKppA5FEiy/bZcfYB3YevkB1oGtlx+wgcG+REREZL3YIkNEREQWi4kMERERWSwmMkRERGSxmMgQERGRxWIiY2Hmz5+Pxx9/HK6urqhduzb69euHpKQkqcOSzIIFCyCTyTBhwgSpQzGrq1ev4oUXXoC3tzccHR0RERGBo0ePSh2WWZSUlGD69OmoV68eHB0dERoaijlz5jx0PRZLtmfPHsTExCAgIAAymQzff/+9zn4hBGbMmAF/f384Ojqia9euSE5OliZYE6iq/Gq1GvHx8YiIiICzszMCAgIwfPhwXLt2TbqATeBh74H7jRkzBjKZDIsXLzZbfFJiImNhEhMTMXbsWBw6dAgJCQlQq9V4+umncffuXalDM7sjR47g008/RWRkpNShmFVmZiY6dOgAhUKBX375BX/88QcWLVoET09PqUMzi/feew8rVqzAsmXLcO7cObz33nt4//338dFHH0kdmsncvXsXzZs3x/Llyyvc//7772Pp0qX45JNPcPjwYTg7O6Nbt24oKCgwc6SmUVX58/LycPz4cUyfPh3Hjx/Hxo0bkZSUhD59+kgQqek87D1QZtOmTTh06BACAgLMFFkNIMiiZWRkCAAiMTFR6lDMKicnRzRs2FAkJCSITp06ifHjx0sdktnEx8eLjh07Sh2GZHr16iVGjRqls61///5i6NChEkVkXgDEpk2btK81Go3w8/MTCxcu1G67c+eOUKlU4uuvv5YgQtN6sPwV+e233wQAcfnyZfMEZWaV1UFaWpqoU6eOOHv2rAgODhYffvih2WOTAltkLFxWVhYAwMvLS+JIzGvs2LHo1asXunbtKnUoZrdlyxa0bt0aAwcORO3atdGyZUt89tlnUodlNu3bt8fOnTtx/vx5AMCpU6ewb98+9OjRQ+LIpHHx4kVcv35d53fB3d0dbdu2xcGDByWMTDpZWVmQyWTw8PCQOhSz0Wg0GDZsGCZPnoymTZtKHY5ZWf2ikdZMo9FgwoQJ6NChA5o1ayZ1OGazbt06HD9+HEeOHJE6FEn89ddfWLFiBSZNmoR///vfOHLkCOLi4qBUKhEbGyt1eCY3ZcoUZGdnIywsDHZ2digpKcG7776LoUOHSh2aJK5fvw4A8PX11dnu6+ur3WdLCgoKEB8fjyFDhljlIoqVee+992Bvb4+4uDipQzE7JjIWbOzYsTh79iz27dsndShmc+XKFYwfPx4JCQlwcHCQOhxJaDQatG7dGvPmzQMAtGzZEmfPnsUnn3xiE4nMt99+i6+++gpr165F06ZNcfLkSUyYMAEBAQE2UX6qnFqtxqBBgyCEwIoVK6QOx2yOHTuGJUuW4Pjx45DJZFKHY3bsWrJQr7/+On788Ufs2rULdevWlTocszl27BgyMjLw2GOPwd7eHvb29khMTMTSpUthb2+PkpISqUM0OX9/fzRp0kRnW3h4OFJTUyWKyLwmT56MKVOm4LnnnkNERASGDRuGiRMnYv78+VKHJgk/Pz8AwI0bN3S237hxQ7vPFpQlMZcvX0ZCQoJNtcbs3bsXGRkZCAoK0v5dvHz5Mt544w2EhIRIHZ7JsUXGwgghMG7cOGzatAm7d+9GvXr1pA7JrLp06YIzZ87obBs5ciTCwsIQHx8POzs7iSIznw4dOpR75P78+fMIDg6WKCLzysvLg1yu+z+YnZ0dNBqNRBFJq169evDz88POnTvRokULAEB2djYOHz6MV199VdrgzKQsiUlOTsauXbvg7e0tdUhmNWzYsHLjBbt164Zhw4Zh5MiREkVlPkxkLMzYsWOxdu1abN68Ga6urto+cHd3dzg6Okocnem5urqWGw/k7OwMb29vmxknNHHiRLRv3x7z5s3DoEGD8Ntvv2HlypVYuXKl1KGZRUxMDN59910EBQWhadOmOHHiBD744AOMGjVK6tBMJjc3FxcuXNC+vnjxIk6ePAkvLy8EBQVhwoQJmDt3Lho2bIh69eph+vTpCAgIQL9+/aQL2oiqKr+/vz+effZZHD9+HD/++CNKSkq0fxe9vLygVCqlCtuoHvYeeDB5UygU8PPzQ+PGjc0dqvlJ/dgUGQZAhV+rV6+WOjTJ2Nrj10II8cMPP4hmzZoJlUolwsLCxMqVK6UOyWyys7PF+PHjRVBQkHBwcBD169cXb7/9tigsLJQ6NJPZtWtXhb/3sbGxQojSR7CnT58ufH19hUqlEl26dBFJSUnSBm1EVZX/4sWLlf5d3LVrl9ShG83D3gMPsqXHr2VCWPF0mERERGTVONiXiIiILBYTGSIiIrJYTGSIiIjIYjGRISIiIovFRIaIiIgsFhMZIiIislhMZIiIiMhiMZEhIiIii8VExsbs3r0bMpkMd+7cMeqxprZ//35ERERAoVDUuGnXTVlPISEhWLx4sdHPawwymQzff/+91GGUY6v3w5J17twZEyZMqLHnM+V1RowYUeP+plkaJjI2pn379khPT4e7u7tRjzW1SZMmoUWLFrh48SLWrFkjdTikB3N9mFiSNWvWwMPDQ+owTG7kyJGYNm2aZNffuHEj5syZI9n1ybyYyFiQoqKiRz6HUqmEn58fZDKZUY81tZSUFDz11FOoW7euTXwQEElNrVZX6+dKSkrw448/ok+fPkaOSH9eXl5wdXWV7PpkXkxkJNK5c2e8/vrreP311+Hu7g4fHx9Mnz4d9y99FRISgjlz5mD48OFwc3PDyy+/DADYt28fnnjiCTg6OiIwMBBxcXG4e/eu9ucKCwsRHx+PwMBAqFQqNGjQAKtWrQJQvtn98uXLiImJgaenJ5ydndG0aVP8/PPPFR4LABs2bEDTpk2hUqkQEhKCRYsW6ZQrJCQE8+bNw6hRo+Dq6oqgoKCHrspcWFiIuLg41K5dGw4ODujYsSOOHDkCALh06RJkMhlu3bqFUaNGQSaTVdoik5mZieHDh8PT0xNOTk7o0aMHkpOTtfvL/hvetm0bwsPD4eLigu7duyM9PV3nPJ9//jnCw8Ph4OCAsLAwfPzxx1XGX2b//v2IjIyEg4MD2rVrh7Nnz+rsf1jdZWRkICYmBo6OjqhXrx6++uornf2jRo1C7969dbap1WrUrl1be38fdOvWLQwZMgR16tSBk5MTIiIi8PXXX+sc07lzZ8TFxeGtt96Cl5cX/Pz8MGvWLJ1jkpOT8eSTT8LBwQFNmjRBQkJClXUxYsQIJCYmYsmSJZDJZJDJZLh06RJat26N//znP9rj+vXrB4VCgdzcXABAWloaZDKZdpXfh93TqtS0+7F7926MHDkSWVlZ2jopq+fCwkK8+eabqFOnDpydndG2bVvs3r1b+7P6vHd3796NNm3awNnZGR4eHujQoQMuX76s3b9ixQqEhoZCqVSicePG+L//+z+d+GQyGVasWIE+ffrA2dkZ7777LjIzMzF06FDUqlULjo6OaNiwIVavXl1lvR84cAAKhQKPP/54hfvv3r2L4cOHw8XFBf7+/uXqXZ/6AErvb+fOneHk5ARPT09069YNmZmZAMq3BoaEhGDu3Lna6wYHB2PLli34+++/0bdvX7i4uCAyMhJHjx7V/ow+vzsPM2vWLLRo0QKffvopAgMD4eTkhEGDBiErK6vSn9m6dSs6duwIDw8PeHt7o3fv3khJSdE5Ji0tDUOGDIGXlxecnZ3RunVrHD58WLt/8+bNeOyxx+Dg4ID69etj9uzZKC4uBgAIITBr1iwEBQVBpVIhICAAcXFxBpWrxpF2zUrb1alTJ+Hi4iLGjx8v/vzzT/Hll18KJycnnVWMg4ODhZubm/jPf/4jLly4oP1ydnYWH374oTh//rzYv3+/aNmypRgxYoT25wYNGiQCAwPFxo0bRUpKitixY4dYt26dEOLeCqqZmZlCCCF69eoloqOjxenTp0VKSor44YcfRGJiYoXHHj16VMjlcvHOO++IpKQksXr1auHo6Kiz8nZwcLDw8vISy5cvF8nJyWL+/PlCLpeLP//8s9K6iIuLEwEBAeLnn38Wv//+u4iNjRWenp7i1q1bori4WKSnpws3NzexePFikZ6eLvLy8io8T58+fUR4eLjYs2ePOHnypOjWrZto0KCBKCoqEkIIsXr1aqFQKETXrl3FkSNHxLFjx0R4eLh4/vnntef48ssvhb+/v9iwYYP466+/xIYNG4SXl5dYs2ZNpfGX1VN4eLjYvn27OH36tOjdu7cICQnRXlufuuvRo4do3ry5OHjwoDh69Kho3769cHR01K5gu3//fmFnZyeuXbum/ZmNGzcKZ2dnkZOTU2FsaWlpYuHCheLEiRMiJSVFLF26VNjZ2YnDhw9rj+nUqZNwc3MTs2bNEufPnxf//e9/hUwmE9u3bxdCCFFSUiKaNWsmunTpIk6ePCkSExNFy5YtBQCxadOmCq97584dERUVJV566SWRnp4u0tPTRXFxsZg0aZLo1auXEKJ0xWYvLy/h4+MjfvnlF23916lTR+97akn3o7CwUCxevFi4ublp66TsuBdffFG0b99e7NmzR1y4cEEsXLhQqFQqcf78eSHEw9+7arVauLu7izfffFNcuHBB/PHHH2LNmjXi8uXL2rgUCoVYvny5SEpKEosWLRJ2dnbi119/1cYHQNSuXVt88cUXIiUlRVy+fFmMHTtWtGjRQhw5ckRcvHhRJCQkiC1btlRa90II8eabb4qXX3650v2vvvqqCAoKEjt27NDeG1dXV50V7B9WHydOnBAqlUq8+uqr4uTJk+Ls2bPio48+En///bcQovQ9ff/5yv4uffLJJ+L8+fPi1VdfFW5ubqJ79+7i22+/FUlJSaJfv34iPDxcaDQaIYT+vzv3X+dBM2fOFM7OzuKpp54SJ06cEImJiaJBgwY6f3NiY2NF3759ta/Xr18vNmzYIJKTk8WJEydETEyMiIiIECUlJUIIIXJyckT9+vXFE088Ifbu3SuSk5PFN998Iw4cOCCEEGLPnj3Czc1NrFmzRqSkpIjt27eLkJAQMWvWLCGEEN99951wc3MTP//8s7h8+bI4fPiwzueOJWIiI5FOnTrp/NIIIUR8fLwIDw/Xvg4ODhb9+vXT+bnRo0eX+yOxd+9eIZfLRX5+vkhKShIAREJCQoXXfTA5iYiI0L7BH3bs888/L6Kjo3WOmTx5smjSpIlOzC+88IL2tUajEbVr1xYrVqyo8Bq5ublCoVCIr776SrutqKhIBAQEiPfff1+7zd3dXedD5kHnz58XAMT+/fu1227evCkcHR3Ft99+K4Qo/TAAIC5cuKA9Zvny5cLX11f7OjQ0VKxdu1bn3HPmzBFRUVGVXrusnsqSRSGEuHXrlnB0dBTffPONEOLhdVd233777Tft/nPnzgkA2g9OIYRo0qSJeO+997SvY2JidJJYffTq1Uu88cYb2tedOnUSHTt21Dnm8ccfF/Hx8UIIIbZt2ybs7e3F1atXtft/+eWXKhOZsvM++Ed+y5Ytwt3dXRQXF4uTJ08KPz8/MX78eO21XnzxRe0feX3uaUVq8v1YvXq1cHd319l2+fJlYWdnp1O/QgjRpUsXMXXqVO3PVfXevXXrlgAgdu/eXeF127dvL1566SWdbQMHDhQ9e/bUvgYgJkyYoHNMTEyMGDlyZKXlqUjDhg3Fjz/+WOG+nJwcoVQqde5f2b0pe6/oUx9DhgwRHTp0qDSGihKZ+/8upaenCwBi+vTp2m0HDx4UAER6enql563od+dhiYydnZ1IS0vTbvvll1+EXC7XXufBROZBf//9twAgzpw5I4QQ4tNPPxWurq7i1q1bFR7fpUsXMW/ePJ1t//d//yf8/f2FEEIsWrRINGrUqMp/BiwNu5Yk1K5dO53xJ1FRUUhOTkZJSYl2W+vWrXV+5tSpU1izZg1cXFy0X926dYNGo8HFixdx8uRJ2NnZoVOnTnrFEBcXh7lz56JDhw6YOXMmTp8+Xemx586dQ4cOHXS2dejQoVzMkZGR2u9lMhn8/PyQkZFR4TlTUlKgVqt1zqtQKNCmTRucO3dOrzKUxWZvb4+2bdtqt3l7e6Nx48Y653FyckJoaKj2tb+/vza2u3fvIiUlBaNHj9ap37lz52qbdnv06KHd3rRpU50YoqKitN97eXnpXPthdVcWf6tWrbT7w8LCyo0HevHFF7VN+zdu3MAvv/yCUaNGVVovJSUlmDNnDiIiIuDl5QUXFxds27YNqampOsfdf88erJdz584hMDAQAQEBFZbVEE888QRycnJw4sQJJCYmolOnTujcubO22yAxMRGdO3fWXvdh99TS7kdFzpw5g5KSEjRq1EjnfZeYmKjTpVDVe9fLywsjRoxAt27dEBMTgyVLluh0O1VW3gd/xx78e/Pqq69i3bp1aNGiBd566y0cOHCgyrKcO3cO165dQ5cuXSrcn5KSgqKiIp17WnZvDKmPkydPVnqNytz/Hvf19QUARERElNtWVqf6/u48TFBQEOrUqaN9HRUVBY1Gg6SkpAqPT05OxpAhQ1C/fn24ubkhJCQEALTXPXnyJFq2bAkvL68Kf/7UqVN45513dOrupZdeQnp6OvLy8jBw4EDk5+ejfv36eOmll7Bp0yZtt5Olspc6AKqas7Ozzuvc3Fy88sorFfZpBgUFaccW6OvFF19Et27d8NNPP2H79u2YP38+Fi1ahHHjxlU7ZoVCofNaJpNBo9FU+3zGVFFs4p9xSWXjND777DOdP7QAYGdnB6B0/Ex+fn6F5zKH4cOHY8qUKTh48CAOHDiAevXq4Yknnqj0+IULF2LJkiVYvHgxIiIi4OzsjAkTJpQbOG6ue+bh4YHmzZtj9+7dOHjwIKKjo/Hkk09i8ODBOH/+PJKTk/VOwgHLux8Vyc3NhZ2dHY4dO6Z9n5VxcXHRfl/VexcAVq9ejbi4OGzduhXffPMNpk2bhoSEBLRr107vWB78e9OjRw9cvnwZP//8MxISEtClSxeMHTtWZ5zT/bZs2YLo6Gg4ODjofc0H6VMfjo6OBp/3/vor+weyom1l73t9f3eMLSYmBsHBwfjss88QEBAAjUaDZs2aaa/7sLLn5uZi9uzZ6N+/f7l9Dg4OCAwMRFJSEnbs2IGEhAS89tprWLhwIRITEyX5HTIGtshI6P7BWQBw6NAhNGzYsNwv7/0ee+wx/PHHH2jQoEG5L6VSiYiICGg0GiQmJuodR2BgIMaMGYONGzfijTfewGeffVbhceHh4di/f7/Otv3796NRo0ZVxlyVssGH959XrVbjyJEjaNKkid7nCQ8PR3FxsU6d3rp1C0lJSXqfx9fXFwEBAfjrr7/K1W29evUAAHXq1NFuCw4O1vn5Q4cOab/PzMzE+fPnER4ero2vqroLCwtDcXExjh07pt2flJRUbi4Ub29v9OvXD6tXr8aaNWswcuTIKsu0f/9+9O3bFy+88AKaN2+O+vXr4/z583rVR5nw8HBcuXJF5z/8+8taGaVSqdNSV6ZTp07YtWsX9uzZg86dO8PLywvh4eF499134e/vj0aNGmmv+7B7amn3o6I6admyJUpKSpCRkVHufefn51fl+R7UsmVLTJ06FQcOHECzZs2wdu3aKsurz+9GrVq1EBsbiy+//BKLFy+ucvD+5s2b0bdv30r3h4aGQqFQ6NzTsntzfxkeVh+RkZHYuXPnQ2N/FMb43QFKW1KuXbumfX3o0CHI5XKdVqgyZe/vadOmoUuXLggPD9cOYC4TGRmJkydP4vbt2xVe77HHHkNSUlKFnxFyeelHvqOjI2JiYrB06VLtPxVnzpwxuGw1BVtkJJSamopJkybhlVdewfHjx/HRRx9VOIL/fvHx8WjXrh1ef/11vPjii3B2dsYff/yBhIQELFu2DCEhIYiNjcWoUaOwdOlSNG/eHJcvX0ZGRgYGDRpU7nwTJkxAjx490KhRI2RmZmLXrl3aP/YPeuONN/D4449jzpw5GDx4MA4ePIhly5bp/VRPRZydnfHqq69i8uTJ8PLyQlBQEN5//33k5eVh9OjRep+nYcOG6Nu3L1566SV8+umncHV1xZQpU1CnTp0q/7A+aPbs2YiLi4O7uzu6d++OwsJCHD16FJmZmZg0aVKVP/vOO+/A29sbvr6+ePvtt+Hj46Od6Ophdde4cWN0794dr7zyClasWAF7e3tMmDChwv++XnzxRfTu3RslJSWIjY19aL2sX78eBw4cgKenJz744APcuHHDoCSxa9euaNSoEWJjY7Fw4UJkZ2fj7bfffujPhYSE4PDhw7h06RJcXFzg5eUFuVyOzp0746OPPkKtWrUQFhYGoPQpk2XLlmHgwIE6sT/KPa2J9yMkJAS5ubnYuXMnmjdvDicnJzRq1AhDhw7F8OHDsWjRIrRs2RJ///03du7cicjISPTq1euhZb148SJWrlyJPn36ICAgAElJSUhOTsbw4cMBAJMnT8agQYPQsmVLdO3aFT/88AM2btyIHTt2VHneGTNmoFWrVmjatCkKCwvx448/Vvr3ISMjA0ePHsWWLVsqPZ+LiwtGjx6NyZMnw9vbG7Vr18bbb7+t/YAFoFd9TJ06FREREXjttdcwZswYKJVK7Nq1CwMHDoSPj89D60sfxvjdAUpbQWJjY/Gf//wH2dnZiIuLw6BBgypMUj09PeHt7Y2VK1fC398fqampmDJlis4xQ4YMwbx589CvXz/Mnz8f/v7+OHHiBAICAhAVFYUZM2agd+/eCAoKwrPPPgu5XI5Tp07h7NmzmDt3LtasWYOSkhK0bdsWTk5O+PLLL+Ho6FjuHwGLIvUgHVvVqVMn8dprr4kxY8YINzc34enpKf7973/rDP4NDg7WGVhY5rfffhPR0dHCxcVFODs7i8jISPHuu+9q9+fn54uJEycKf39/oVQqRYMGDcQXX3whhCg/gPf1118XoaGhQqVSiVq1aolhw4aJmzdvVnisEKUj6ps0aSIUCoUICgoSCxcu1ImtopibN28uZs6cWWld5Ofni3HjxgkfHx+hUqlEhw4ddAZZCvHwwb5CCHH79m0xbNgw4e7uLhwdHUW3bt20TzkIUfFAy02bNokHfw2++uor0aJFC6FUKoWnp6d48sknxcaNGyu9blk9/fDDD6Jp06ZCqVSKNm3aiFOnTukc97C6S09PF7169RIqlUoEBQWJ//3vfxXWp0ajEcHBwToDNStz69Yt0bdvX+Hi4iJq164tpk2bJoYPH64zuLCiAYt9+/YVsbGx2tdJSUmiY8eOQqlUikaNGomtW7c+dLBvUlKSaNeunXB0dBQAxMWLF7UxyWQyMXjwYO2xZffhk08+0TnHw+5pRWry/RBCiDFjxghvb28BQPt7UVRUJGbMmCFCQkKEQqEQ/v7+4plnnhGnT58WQjz8vXv9+nXRr18/7e98cHCwmDFjhvZJFyGE+Pjjj0X9+vWFQqEQjRo1Ev/73/90zlfR/ZwzZ44IDw8Xjo6OwsvLS/Tt21f89ddfFZbr888/r3IAbpmcnBzxwgsvCCcnJ+Hr6yvef//9cu/Bh9WHEELs3r1btG/fXqhUKuHh4SG6deum/VtV0WDfB+/bg+W9ePGiACBOnDghhKj+7879Zs6cKZo3by4+/vhjERAQIBwcHMSzzz4rbt++rT3mwcG+CQkJIjw8XKhUKhEZGSl2795dLtZLly6JAQMGCDc3N+Hk5CRat26t8zTV1q1btU/Zubm5iTZt2mifTNq0aZNo27atcHNzE87OzqJdu3Zix44dlZbBEsiEuK+Tlcymc+fOaNGiBac7J4Pl5uaiTp06WL16dYX94GRevB+l+vTpg44dO+Ktt96SOpQaY9asWfj+++9x8uRJqUOxauxaIrIQGo0GN2/exKJFi+Dh4SHpzKnE+/Ggjh07YsiQIVKHQTaIiQyRhUhNTUW9evVQt25drFmzBvb2/PWVEu+HLrbEkFTYtUREREQWi49fExERkcViIkNEREQWi4kMERERWSwmMkRERGSxmMgQERGRxWIiQ0RERBaLiQwRERFZLCYyREREZLH+H2zKEFjPquCfAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -336,9 +336,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.78391574155206\n", - "LUCJ energy = -77.84651018653351\n", - "FCI energy = -77.87421656438626\n" + "LUCJ (MPS) energy = -77.77107786723349\n", + "LUCJ energy = -77.84651018653341\n", + "FCI energy = -77.87421656438624\n" ] } ], @@ -386,7 +386,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -468,6 +468,83 @@ "source": [ "From the above plots, we can see that above an MPS bond dimension of 16, the MPS representation of the LUCJ circuit is exact." ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4caf5964-083f-40e3-8b04-f6c738555c3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spin.ALPHA\n" + ] + } + ], + "source": [ + "from ffsim.spin import Spin\n", + "\n", + "print(Spin.ALPHA)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b1a31c0f-b6f8-4491-9ee0-0e78a73e0514", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(Spin.ALPHA)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4fe11660-1882-4001-8e8e-0c3e8742e19f", + "metadata": {}, + "outputs": [], + "source": [ + "a = Spin.ALPHA" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c0095a3a-4631-4da1-a968-8c1e70f0afd1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spin.ALPHA\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b55b15c-eb71-489b-9f41-3300de376846", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index f3d12cb4a..937ec6846 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -15,6 +15,9 @@ cphase2, gate1, gate2, + givens_rotation, + num_interaction, + on_site_interaction, phase, sym_cons_basis, xy, @@ -29,9 +32,12 @@ "cphase2", "gate1", "gate2", + "givens_rotation", "lucj_circuit_as_mps", "MolecularChain", "MolecularHamiltonianMPOModel", + "num_interaction", + "on_site_interaction", "phase", "product_state_as_mps", "sym_cons_basis", diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 9eaf47ceb..eb182a9df 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -6,6 +6,8 @@ from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite +from ffsim.spin import Spin + # ignore lowercase argument and variable checks to maintain TeNPy naming conventions # ruff: noqa: N803, N806 @@ -44,6 +46,103 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: return gate_sym +def givens_rotation( + theta: float, spin: Spin, conj: bool = False, *, phi: float = 0.0 +) -> np.ndarray: + r"""The Givens gate. + + The Givens rotation gate as defined in the + `ffsim documentation `__, + returned in the TeNPy (N, Sz)-symmetry-conserved basis. + + Args: + theta: The rotation angle. + spin: Choice of spin sector(s) to act on. + + - To act on only spin alpha, pass :const:`ffsim.Spin.ALPHA`. + - To act on only spin beta, pass :const:`ffsim.Spin.BETA`. + - To act on both spin alpha and spin beta, pass + :const:`ffsim.Spin.ALPHA_AND_BETA`. + conj: The direction of the gate. By default, we use the little endian + convention, as in Qiskit. + phi: The phase angle. + + Returns: + The Givens rotation gate in the TeNPy (N, Sz)-symmetry-conserved basis. + """ + + # translate angle parameters + theta = 2 * theta + phi = phi + np.pi / 2 + + # define conjugate operator + if conj: + phi = -phi + + # define operators + Id = shfs_nosym.get_op("Id").to_ndarray() + JW = shfs_nosym.get_op("JW").to_ndarray() + + # alpha sector / up spins + if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: + Cdu = shfs_nosym.get_op("Cdu").to_ndarray() + Cu = shfs_nosym.get_op("Cu").to_ndarray() + JWu = shfs_nosym.get_op("JWu").to_ndarray() + Nu = shfs_nosym.get_op("Nu").to_ndarray() + # + Xu1 = (Cdu + Cu) @ JW + Xu2 = (Cdu + Cu) @ JWu + Yu1 = -1j * (Cdu - Cu) @ JW + Yu2 = -1j * (Cdu - Cu) @ JWu + Zu = 2 * Nu - Id + RZu0 = np.kron(sp.linalg.expm(-1j * (phi / 2) * Zu), Id) + # + XYgate_a = ( + np.conj(RZu0) + @ sp.linalg.expm( + -1j * (theta / 4) * (np.kron(Xu1, Xu2) + np.kron(Yu1, Yu2)) + ) + @ RZu0 + ) + + # beta sector / down spins + if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: + Cdd = shfs_nosym.get_op("Cdd").to_ndarray() + Cd = shfs_nosym.get_op("Cd").to_ndarray() + JWd = shfs_nosym.get_op("JWd").to_ndarray() + Nd = shfs_nosym.get_op("Nd").to_ndarray() + # + Xd1 = (Cdd + Cd) @ JW + Xd2 = (Cdd + Cd) @ JWd + Yd1 = -1j * (Cdd - Cd) @ JW + Yd2 = -1j * (Cdd - Cd) @ JWd + Zd = 2 * Nd - Id + RZd0 = np.kron(sp.linalg.expm(-1j * (phi / 2) * Zd), Id) + # + XYgate_b = ( + np.conj(RZd0) + @ sp.linalg.expm( + -1j * (theta / 4) * (np.kron(Xd1, Xd2) + np.kron(Yd1, Yd2)) + ) + @ RZd0 + ) + + # define total gate + if spin is Spin.ALPHA: + XYgate = XYgate_a + elif spin is Spin.BETA: + XYgate = XYgate_b + elif spin is Spin.ALPHA_AND_BETA: + XYgate = XYgate_a @ XYgate_b + else: + raise ValueError("undefined spin") + + # convert to (N, Sz)-symmetry-conserved basis + XYgate_sym = sym_cons_basis(XYgate) + + return XYgate_sym + + def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: r"""The XXPlusYY gate. @@ -121,6 +220,59 @@ def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: return XYgate_sym +def num_interaction(theta: float, spin: Spin) -> np.ndarray: + r"""The number interaction gate. + + The number interaction gate as defined in the + `ffsim documentation `__, + returned in the TeNPy (N, Sz)-symmetry-conserved basis. + + Args: + theta: The rotation angle. + spin: Choice of spin sector(s) to act on. + + - To act on only spin alpha, pass :const:`ffsim.Spin.ALPHA`. + - To act on only spin beta, pass :const:`ffsim.Spin.BETA`. + - To act on both spin alpha and spin beta, pass + :const:`ffsim.Spin.ALPHA_AND_BETA` (this is the default value). + + Returns: + The number interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. + """ + + # define operators + Id = shfs_nosym.get_op("Id").to_ndarray() + + # alpha sector / up spins + if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: + Nu = shfs_nosym.get_op("Nu").to_ndarray() + Zu = 2 * Nu - Id + RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) + Pgate_a = np.exp(1j * (theta / 2)) * RZu + + # beta sector / down spins + if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: + Nd = shfs_nosym.get_op("Nd").to_ndarray() + Zd = 2 * Nd - Id + RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) + Pgate_b = np.exp(1j * (theta / 2)) * RZd + + # define total gate + if spin is Spin.ALPHA: + Pgate = Pgate_a + elif spin is Spin.BETA: + Pgate = Pgate_b + elif spin is Spin.ALPHA_AND_BETA: + Pgate = Pgate_a @ Pgate_b + else: + raise ValueError("undefined spin") + + # convert to (N, Sz)-symmetry-conserved basis + Pgate_sym = sym_cons_basis(Pgate) + + return Pgate_sym + + def phase(spin: str, theta: float) -> np.ndarray: r"""The Phase gate. @@ -160,6 +312,29 @@ def phase(spin: str, theta: float) -> np.ndarray: return Pgate_sym +def on_site_interaction(theta: float) -> np.ndarray: + r"""The on-site interaction gate. + + The on-site interaction gate as defined in the + `ffsim documentation `__, + returned in the TeNPy (N, Sz)-symmetry-conserved basis. + + Args: + theta: The rotation angle. + + Returns: + The on-site interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. + """ + + CPgate = np.eye(4, dtype=complex) + CPgate[3, 3] = np.exp(-1j * theta) # minus sign + + # convert to (N, Sz)-symmetry-conserved basis + CPgate_sym = sym_cons_basis(CPgate) + + return CPgate_sym + + def cphase1(theta: float) -> np.ndarray: r"""The single-site CPhase gate. diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index dae78b48f..5506001b5 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -6,13 +6,14 @@ from tenpy.networks.mps import MPS import ffsim +from ffsim.spin import Spin from ffsim.tenpy.circuits.gates import ( - cphase1, cphase2, gate1, gate2, - phase, - xy, + givens_rotation, + num_interaction, + on_site_interaction, ) from ffsim.tenpy.util import product_state_as_mps from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced @@ -64,17 +65,17 @@ def lucj_circuit_as_mps( if ins.operation.name == "p": qubit = ins.qubits[0] idx = qubit._index - spin_flag = "up" if idx < norb else "down" + spin_flag = Spin.ALPHA if idx < norb else Spin.BETA lmbda = ins.operation.params[0] - gate1(phase(spin_flag, lmbda), idx % norb, psi) + gate1(num_interaction(lmbda, spin_flag), idx % norb, psi) elif ins.operation.name == "xx_plus_yy": qubit0 = ins.qubits[0] qubit1 = ins.qubits[1] idx0, idx1 = qubit0._index, qubit1._index if idx0 < norb and idx1 < norb: - spin_flag = "up" + spin_flag = Spin.ALPHA elif idx0 >= norb and idx1 >= norb: - spin_flag = "down" + spin_flag = Spin.BETA else: raise ValueError("XXPlusYY gate not allowed across spin sectors") theta_val = ins.operation.params[0] @@ -82,7 +83,9 @@ def lucj_circuit_as_mps( # directionality important when beta!=0 conj_flag = True if idx0 > idx1 else False gate2( - xy(spin_flag, theta_val, beta_val, conj_flag), + givens_rotation( + theta_val / 2, spin_flag, conj_flag, phi=beta_val - np.pi / 2 + ), max(idx0 % norb, idx1 % norb), psi, eng, @@ -96,7 +99,7 @@ def lucj_circuit_as_mps( lmbda = ins.operation.params[0] # onsite (different spins) if np.abs(idx0 - idx1) == norb: - gate1(cphase1(lmbda), min(idx0, idx1), psi) + gate1(on_site_interaction(lmbda), min(idx0, idx1), psi) # NN (up spins) elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: gate2( From 20c24ce81f3be1d5835cd21807978ab91776f902 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Wed, 6 Nov 2024 11:56:47 +0100 Subject: [PATCH 30/88] finish transition from qubit to fermionic gate names --- docs/how-to-guides/lucj_mps.ipynb | 89 +----- python/ffsim/tenpy/__init__.py | 10 +- python/ffsim/tenpy/circuits/gates.py | 312 +++++--------------- python/ffsim/tenpy/circuits/lucj_circuit.py | 17 +- 4 files changed, 87 insertions(+), 341 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index ee45e18b4..3b75d26b9 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -34,7 +34,7 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp7r2dc_fs\n", + "Parsing /tmp/tmpibrj_a18\n", "converged SCF energy = -77.8266321248744\n", "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.8742153637403 E_corr = -0.04758323886584406\n" + "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585264\n" ] }, { @@ -216,7 +216,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -336,8 +336,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77107786723349\n", - "LUCJ energy = -77.84651018653341\n", + "LUCJ (MPS) energy = -77.77107802937196\n", + "LUCJ energy = -77.84651018653345\n", "FCI energy = -77.87421656438624\n" ] } @@ -386,7 +386,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -468,83 +468,6 @@ "source": [ "From the above plots, we can see that above an MPS bond dimension of 16, the MPS representation of the LUCJ circuit is exact." ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4caf5964-083f-40e3-8b04-f6c738555c3e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Spin.ALPHA\n" - ] - } - ], - "source": [ - "from ffsim.spin import Spin\n", - "\n", - "print(Spin.ALPHA)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b1a31c0f-b6f8-4491-9ee0-0e78a73e0514", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(Spin.ALPHA)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "4fe11660-1882-4001-8e8e-0c3e8742e19f", - "metadata": {}, - "outputs": [], - "source": [ - "a = Spin.ALPHA" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c0095a3a-4631-4da1-a968-8c1e70f0afd1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Spin.ALPHA\n" - ] - } - ], - "source": [ - "print(a)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0b55b15c-eb71-489b-9f41-3300de376846", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 937ec6846..622bfdbaf 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -11,16 +11,13 @@ """Code that uses TeNPy, e.g. for emulating quantum circuits.""" from ffsim.tenpy.circuits.gates import ( - cphase1, - cphase2, gate1, gate2, givens_rotation, num_interaction, + num_num_interaction, on_site_interaction, - phase, sym_cons_basis, - xy, ) from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps from ffsim.tenpy.hamiltonians.lattices import MolecularChain @@ -28,8 +25,6 @@ from ffsim.tenpy.util import product_state_as_mps __all__ = [ - "cphase1", - "cphase2", "gate1", "gate2", "givens_rotation", @@ -37,9 +32,8 @@ "MolecularChain", "MolecularHamiltonianMPOModel", "num_interaction", + "num_num_interaction", "on_site_interaction", - "phase", "product_state_as_mps", "sym_cons_basis", - "xy", ] diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index eb182a9df..5ce0db0ba 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -49,10 +49,10 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: def givens_rotation( theta: float, spin: Spin, conj: bool = False, *, phi: float = 0.0 ) -> np.ndarray: - r"""The Givens gate. + r"""The Givens rotation gate. - The Givens rotation gate as defined in the - `ffsim documentation `__, + The Givens rotation gate as defined in + `apply_givens_rotation `__, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -71,13 +71,11 @@ def givens_rotation( The Givens rotation gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - # translate angle parameters - theta = 2 * theta - phi = phi + np.pi / 2 - - # define conjugate operator + # define conjugate phase if conj: - phi = -phi + beta = phi + np.pi / 2 + beta = -beta + phi = beta - np.pi / 2 # define operators Id = shfs_nosym.get_op("Id").to_ndarray() @@ -90,19 +88,12 @@ def givens_rotation( JWu = shfs_nosym.get_op("JWu").to_ndarray() Nu = shfs_nosym.get_op("Nu").to_ndarray() # - Xu1 = (Cdu + Cu) @ JW - Xu2 = (Cdu + Cu) @ JWu - Yu1 = -1j * (Cdu - Cu) @ JW - Yu2 = -1j * (Cdu - Cu) @ JWu - Zu = 2 * Nu - Id - RZu0 = np.kron(sp.linalg.expm(-1j * (phi / 2) * Zu), Id) - # - XYgate_a = ( - np.conj(RZu0) + Ggate_a = ( + np.kron(sp.linalg.expm(1j * phi * Nu), Id) @ sp.linalg.expm( - -1j * (theta / 4) * (np.kron(Xu1, Xu2) + np.kron(Yu1, Yu2)) + theta * (np.kron(Cdu @ JW, Cu @ JWu) - np.kron(Cu @ JW, Cdu @ JWu)) ) - @ RZu0 + @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) ) # beta sector / down spins @@ -112,119 +103,35 @@ def givens_rotation( JWd = shfs_nosym.get_op("JWd").to_ndarray() Nd = shfs_nosym.get_op("Nd").to_ndarray() # - Xd1 = (Cdd + Cd) @ JW - Xd2 = (Cdd + Cd) @ JWd - Yd1 = -1j * (Cdd - Cd) @ JW - Yd2 = -1j * (Cdd - Cd) @ JWd - Zd = 2 * Nd - Id - RZd0 = np.kron(sp.linalg.expm(-1j * (phi / 2) * Zd), Id) - # - XYgate_b = ( - np.conj(RZd0) + Ggate_b = ( + np.kron(sp.linalg.expm(1j * phi * Nd), Id) @ sp.linalg.expm( - -1j * (theta / 4) * (np.kron(Xd1, Xd2) + np.kron(Yd1, Yd2)) + theta * (np.kron(Cdd @ JW, Cd @ JWd) - np.kron(Cd @ JW, Cdd @ JWd)) ) - @ RZd0 + @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) ) # define total gate if spin is Spin.ALPHA: - XYgate = XYgate_a + Ggate = Ggate_a elif spin is Spin.BETA: - XYgate = XYgate_b + Ggate = Ggate_b elif spin is Spin.ALPHA_AND_BETA: - XYgate = XYgate_a @ XYgate_b - else: - raise ValueError("undefined spin") - - # convert to (N, Sz)-symmetry-conserved basis - XYgate_sym = sym_cons_basis(XYgate) - - return XYgate_sym - - -def xy(spin: str, theta: float, beta: float, conj: bool = False) -> np.ndarray: - r"""The XXPlusYY gate. - - The XXPlusYY gate as defined in the - `Qiskit documentation `__, - returned in the TeNPy (N, Sz)-symmetry-conserved basis. - - Args: - spin: The spin sector ("up" or "down"). - theta: The rotation angle. - beta: The phase angle. - conj: The direction of the gate. By default, we use the little endian - convention, as in Qiskit. - - Returns: - The XXPlusYY gate in the TeNPy (N, Sz)-symmetry-conserved basis. - """ - - # define conjugate operator - if conj: - beta = -beta - - # define operators - Id = shfs_nosym.get_op("Id").to_ndarray() - JW = shfs_nosym.get_op("JW").to_ndarray() - - if spin == "up": - # alpha sector / up spins - Cdu = shfs_nosym.get_op("Cdu").to_ndarray() - Cu = shfs_nosym.get_op("Cu").to_ndarray() - JWu = shfs_nosym.get_op("JWu").to_ndarray() - Nu = shfs_nosym.get_op("Nu").to_ndarray() - # - Xu1 = (Cdu + Cu) @ JW - Xu2 = (Cdu + Cu) @ JWu - Yu1 = -1j * (Cdu - Cu) @ JW - Yu2 = -1j * (Cdu - Cu) @ JWu - Zu = 2 * Nu - Id - RZu0 = np.kron(sp.linalg.expm(-1j * (beta / 2) * Zu), Id) - # - XYgate = ( - np.conj(RZu0) - @ sp.linalg.expm( - -1j * (theta / 4) * (np.kron(Xu1, Xu2) + np.kron(Yu1, Yu2)) - ) - @ RZu0 - ) - elif spin == "down": - # beta sector / down spins - Cdd = shfs_nosym.get_op("Cdd").to_ndarray() - Cd = shfs_nosym.get_op("Cd").to_ndarray() - JWd = shfs_nosym.get_op("JWd").to_ndarray() - Nd = shfs_nosym.get_op("Nd").to_ndarray() - # - Xd1 = (Cdd + Cd) @ JW - Xd2 = (Cdd + Cd) @ JWd - Yd1 = -1j * (Cdd - Cd) @ JW - Yd2 = -1j * (Cdd - Cd) @ JWd - Zd = 2 * Nd - Id - RZd0 = np.kron(sp.linalg.expm(-1j * (beta / 2) * Zd), Id) - # - XYgate = ( - np.conj(RZd0) - @ sp.linalg.expm( - -1j * (theta / 4) * (np.kron(Xd1, Xd2) + np.kron(Yd1, Yd2)) - ) - @ RZd0 - ) + Ggate = Ggate_a @ Ggate_b else: raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - XYgate_sym = sym_cons_basis(XYgate) + Ggate_sym = sym_cons_basis(Ggate) - return XYgate_sym + return Ggate_sym def num_interaction(theta: float, spin: Spin) -> np.ndarray: r"""The number interaction gate. - The number interaction gate as defined in the - `ffsim documentation `__, + The number interaction gate as defined in + `apply_num_interaction `__, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -240,83 +147,37 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: The number interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - # define operators - Id = shfs_nosym.get_op("Id").to_ndarray() - # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: Nu = shfs_nosym.get_op("Nu").to_ndarray() - Zu = 2 * Nu - Id - RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) - Pgate_a = np.exp(1j * (theta / 2)) * RZu + Ngate_a = sp.linalg.expm(1j * theta * Nu) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: Nd = shfs_nosym.get_op("Nd").to_ndarray() - Zd = 2 * Nd - Id - RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) - Pgate_b = np.exp(1j * (theta / 2)) * RZd + Ngate_b = sp.linalg.expm(1j * theta * Nd) # define total gate if spin is Spin.ALPHA: - Pgate = Pgate_a + Ngate = Ngate_a elif spin is Spin.BETA: - Pgate = Pgate_b + Ngate = Ngate_b elif spin is Spin.ALPHA_AND_BETA: - Pgate = Pgate_a @ Pgate_b + Ngate = Ngate_a @ Ngate_b else: raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - Pgate_sym = sym_cons_basis(Pgate) - - return Pgate_sym + Ngate_sym = sym_cons_basis(Ngate) - -def phase(spin: str, theta: float) -> np.ndarray: - r"""The Phase gate. - - The Phase gate as defined in the - `Qiskit documentation `__, - returned in the TeNPy (N, Sz)-symmetry-conserved basis. - - Args: - spin: The spin sector ("up" or "down"). - theta: The rotation angle. - - Returns: - The Phase gate in the TeNPy (N, Sz)-symmetry-conserved basis. - """ - - # define operators - Id = shfs_nosym.get_op("Id").to_ndarray() - - if spin == "up": - # alpha sector / up spins - Nu = shfs_nosym.get_op("Nu").to_ndarray() - Zu = 2 * Nu - Id - RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) - Pgate = np.exp(1j * (theta / 2)) * RZu - elif spin == "down": - # beta sector / down spins - Nd = shfs_nosym.get_op("Nd").to_ndarray() - Zd = 2 * Nd - Id - RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) - Pgate = np.exp(1j * (theta / 2)) * RZd - else: - raise ValueError("undefined spin") - - # convert to (N, Sz)-symmetry-conserved basis - Pgate_sym = sym_cons_basis(Pgate) - - return Pgate_sym + return Ngate_sym def on_site_interaction(theta: float) -> np.ndarray: r"""The on-site interaction gate. - The on-site interaction gate as defined in the - `ffsim documentation `__, + The on-site interaction gate as defined in + `apply_on_site_interaction `__, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -326,105 +187,66 @@ def on_site_interaction(theta: float) -> np.ndarray: The on-site interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - CPgate = np.eye(4, dtype=complex) - CPgate[3, 3] = np.exp(-1j * theta) # minus sign - - # convert to (N, Sz)-symmetry-conserved basis - CPgate_sym = sym_cons_basis(CPgate) - - return CPgate_sym - - -def cphase1(theta: float) -> np.ndarray: - r"""The single-site CPhase gate. - - The single-site CPhase gate as defined in the - `Qiskit documentation `__, - returned in the TeNPy (N, Sz)-symmetry-conserved basis. - - .. note:: - A two-site CPhase gate in the qubit basis may translate to a single-site CPhase - gate in the fermion basis. - - Args: - theta: The rotation angle. - - Returns: - The single-site CPhase gate in the TeNPy (N, Sz)-symmetry-conserved basis. - """ + # define operators + Nu = shfs_nosym.get_op("Nu").to_ndarray() + Nd = shfs_nosym.get_op("Nd").to_ndarray() - CPgate = np.eye(4, dtype=complex) - CPgate[3, 3] = np.exp(-1j * theta) # minus sign + # define total gate + OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) # convert to (N, Sz)-symmetry-conserved basis - CPgate_sym = sym_cons_basis(CPgate) + OSgate_sym = sym_cons_basis(OSgate) - return CPgate_sym + return OSgate_sym -def cphase2(spin: str, theta: float) -> np.ndarray: - r"""The two-site CPhase gate. +def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: + r"""The number-number interaction gate. - The two-site CPhase gate as defined in the - `Qiskit documentation `__, + The number-number interaction gate as defined in + `apply_num_num_interaction `__, returned in the TeNPy (N, Sz)-symmetry-conserved basis. - .. note:: - A two-site CPhase gate in the qubit basis may translate to a single-site CPhase - gate in the fermion basis. - Args: - spin: The spin sector ("up" or "down"). theta: The rotation angle. + spin: Choice of spin sector(s) to act on. + + - To act on only spin alpha, pass :const:`ffsim.Spin.ALPHA`. + - To act on only spin beta, pass :const:`ffsim.Spin.BETA`. + - To act on both spin alpha and spin beta, pass + :const:`ffsim.Spin.ALPHA_AND_BETA` (this is the default value). Returns: - The two-site CPhase gate in the TeNPy (N, Sz)-symmetry-conserved basis. + The number-number interaction gate in the TeNPy (N, Sz)-symmetry-conserved + basis. """ # define operators - Id = shfs_nosym.get_op("Id").to_ndarray() + Nu = shfs_nosym.get_op("Nu").to_ndarray() + Nd = shfs_nosym.get_op("Nd").to_ndarray() - state_0 = np.array([1, 0, 0, 0]) - state_1 = np.array([0, 1, 0, 0]) - state_2 = np.array([0, 0, 1, 0]) - state_3 = np.array([0, 0, 0, 1]) + # alpha sector / up spins + if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: + NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) - outer_0 = np.outer(state_0, state_0) - outer_1 = np.outer(state_1, state_1) - outer_2 = np.outer(state_2, state_2) - outer_3 = np.outer(state_3, state_3) + # beta sector / down spins + if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: + NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) - if spin == "up": - # alpha sector / up spins - Nu = shfs_nosym.get_op("Nu").to_ndarray() - Zu = 2 * Nu - Id - RZu = sp.linalg.expm(-1j * (theta / 2) * Zu) - Pup = np.exp(-1j * (theta / 2)) * RZu # minus sign - CPgate = ( - np.kron(outer_0, Id) - + np.kron(outer_1, Pup) - + np.kron(outer_2, Id) - + np.kron(outer_3, Pup) - ) - elif spin == "down": - # beta sector / down spins - Nd = shfs_nosym.get_op("Nd").to_ndarray() - Zd = 2 * Nd - Id - RZd = sp.linalg.expm(-1j * (theta / 2) * Zd) - Pdw = np.exp(-1j * (theta / 2)) * RZd # minus sign - CPgate = ( - np.kron(outer_0, Id) - + np.kron(outer_1, Id) - + np.kron(outer_2, Pdw) - + np.kron(outer_3, Pdw) - ) + # define total gate + if spin is Spin.ALPHA: + NNgate = NNgate_a + elif spin is Spin.BETA: + NNgate = NNgate_b + elif spin is Spin.ALPHA_AND_BETA: + NNgate = NNgate_a @ NNgate_b else: raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - CPgate_sym = sym_cons_basis(CPgate) + NNgate_sym = sym_cons_basis(NNgate) - return CPgate_sym + return NNgate_sym def gate1(U1: np.ndarray, site: int, psi: MPS) -> None: diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 5506001b5..c3b57013c 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -8,11 +8,11 @@ import ffsim from ffsim.spin import Spin from ffsim.tenpy.circuits.gates import ( - cphase2, gate1, gate2, givens_rotation, num_interaction, + num_num_interaction, on_site_interaction, ) from ffsim.tenpy.util import product_state_as_mps @@ -67,7 +67,9 @@ def lucj_circuit_as_mps( idx = qubit._index spin_flag = Spin.ALPHA if idx < norb else Spin.BETA lmbda = ins.operation.params[0] - gate1(num_interaction(lmbda, spin_flag), idx % norb, psi) + gate1( + np.exp(1j * lmbda) * num_interaction(-lmbda, spin_flag), idx % norb, psi + ) elif ins.operation.name == "xx_plus_yy": qubit0 = ins.qubits[0] qubit1 = ins.qubits[1] @@ -99,16 +101,21 @@ def lucj_circuit_as_mps( lmbda = ins.operation.params[0] # onsite (different spins) if np.abs(idx0 - idx1) == norb: - gate1(on_site_interaction(lmbda), min(idx0, idx1), psi) + gate1(on_site_interaction(-lmbda), min(idx0, idx1), psi) # NN (up spins) elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: gate2( - cphase2("up", lmbda), max(idx0, idx1), psi, eng, chi_list, norm_tol + num_num_interaction(-lmbda, Spin.ALPHA), + max(idx0, idx1), + psi, + eng, + chi_list, + norm_tol, ) # NN (down spins) elif np.abs(idx0 - idx1) == 1 and idx0 >= norb and idx1 >= norb: gate2( - cphase2("down", lmbda), + num_num_interaction(-lmbda, Spin.BETA), max(idx0 % norb, idx1 % norb), psi, eng, From 6be63f1510ff045621280e4f91585589074fef58 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Wed, 6 Nov 2024 12:35:04 +0100 Subject: [PATCH 31/88] minor change to NNgate --- python/ffsim/tenpy/circuits/gates.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 5ce0db0ba..87cfe97a9 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -221,16 +221,14 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: basis. """ - # define operators - Nu = shfs_nosym.get_op("Nu").to_ndarray() - Nd = shfs_nosym.get_op("Nd").to_ndarray() - # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: + Nu = shfs_nosym.get_op("Nu").to_ndarray() NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: + Nd = shfs_nosym.get_op("Nd").to_ndarray() NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) # define total gate From e99749183992e7c92f23a03f8a480a26b5d85f24 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 7 Nov 2024 14:43:15 +0100 Subject: [PATCH 32/88] apply UCJ operator directly --- docs/how-to-guides/lucj_mps.ipynb | 29 ++--- python/ffsim/tenpy/__init__.py | 12 +- python/ffsim/tenpy/circuits/gates.py | 117 +++++++++++++++++++- python/ffsim/tenpy/circuits/lucj_circuit.py | 99 +++-------------- tests/python/tenpy/lucj_circuit_test.py | 4 +- 5 files changed, 147 insertions(+), 114 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 3b75d26b9..593d9c57b 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -34,9 +34,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmpibrj_a18\n", + "Parsing /tmp/tmp1e4pf6nc\n", "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -45,7 +45,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_ovlp get_hcore of \n", + "Overwritten attributes get_hcore get_ovlp of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -120,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585264\n" + "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585367\n" ] }, { @@ -184,7 +184,7 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 54\n" + "maximum MPO bond dimension = 58\n" ] } ], @@ -336,9 +336,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77107802937196\n", + "LUCJ (MPS) energy = -77.77102667787551\n", "LUCJ energy = -77.84651018653345\n", - "FCI energy = -77.87421656438624\n" + "FCI energy = -77.87421656438627\n" ] } ], @@ -380,21 +380,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.gridspec as gridspec\n", "\n", diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 622bfdbaf..bb0f692cf 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -11,8 +11,10 @@ """Code that uses TeNPy, e.g. for emulating quantum circuits.""" from ffsim.tenpy.circuits.gates import ( - gate1, - gate2, + apply_diag_coulomb_evolution, + apply_gate1, + apply_gate2, + apply_orbital_rotation, givens_rotation, num_interaction, num_num_interaction, @@ -25,8 +27,10 @@ from ffsim.tenpy.util import product_state_as_mps __all__ = [ - "gate1", - "gate2", + "apply_diag_coulomb_evolution", + "apply_gate1", + "apply_gate2", + "apply_orbital_rotation", "givens_rotation", "lucj_circuit_as_mps", "MolecularChain", diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 87cfe97a9..9175dbd24 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -6,6 +6,7 @@ from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite +from ffsim.linalg import givens_decomposition from ffsim.spin import Spin # ignore lowercase argument and variable checks to maintain TeNPy naming conventions @@ -247,7 +248,7 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: return NNgate_sym -def gate1(U1: np.ndarray, site: int, psi: MPS) -> None: +def apply_gate1(U1: np.ndarray, site: int, psi: MPS) -> None: r"""Apply a single-site gate to a `TeNPy MPS `__ wavefunction. @@ -257,7 +258,8 @@ def gate1(U1: np.ndarray, site: int, psi: MPS) -> None: site: The gate will be applied to `site` on the `TeNPy MPS `__ wavefunction. - psi: The wavefunction MPS. + psi: The `TeNPy MPS `__ + wavefunction. Returns: None @@ -268,13 +270,13 @@ def gate1(U1: np.ndarray, site: int, psi: MPS) -> None: psi.apply_local_op(site, U1_npc) -def gate2( +def apply_gate2( U2: np.ndarray, site: int, psi: MPS, eng: TEBDEngine, chi_list: list, - norm_tol: float, + norm_tol: float = 1e-5, ) -> None: r"""Apply a two-site gate to a `TeNPy MPS `__ wavefunction. @@ -308,3 +310,110 @@ def gate2( # recanonicalize psi if below error threshold if np.linalg.norm(psi.norm_test()) > norm_tol: psi.canonical_form_finite() + + +def apply_orbital_rotation( + mat: np.ndarray, + psi: MPS, + eng: TEBDEngine, + chi_list: list, + norm_tol: float = 1e-5, +) -> None: + r"""Apply an orbital rotation gate to a + `TeNPy MPS `__ + wavefunction. + + The orbital rotation gate is defined in + `apply_orbital_rotation `__. + + Args: + mat: The orbital rotation matrix of dimension `(norb, norb)`. + psi: The `TeNPy MPS `__ + wavefunction. + eng: The + `TeNPy TEBDEngine `__. + chi_list: The list to which to append the MPS bond dimensions as the circuit is + evaluated. + norm_tol: The norm error above which we recanonicalize the wavefunction, as + defined in the + `TeNPy documentation `__. + + Returns: + None + """ + + # Givens decomposition + givens_list, diag_mat = givens_decomposition(mat) + + # apply the Givens rotation gates + for gate in givens_list: + theta = np.arccos(gate.c) + s = np.conj(gate.s) + phi = np.real(1j * np.log(-s / np.sin(theta))) if theta else 0 + conj = True if gate.j < gate.i else False + apply_gate2( + givens_rotation(theta, Spin.ALPHA_AND_BETA, conj, phi=phi), + max(gate.i, gate.j), + psi, + eng, + chi_list, + norm_tol, + ) + + # apply the number interaction gates + for i, z in enumerate(diag_mat): + theta = float(np.angle(z)) + apply_gate1( + np.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i, psi + ) + + +def apply_diag_coulomb_evolution( + mat: np.ndarray, psi: MPS, eng: TEBDEngine, chi_list: list, norm_tol: float = 1e-5 +) -> None: + r"""Apply a diagonal Coulomb evolution gate to a + `TeNPy MPS `__ + wavefunction. + + The diagonal Coulomb evolution gate is defined in + `apply_diag_coulomb_evolution `__. + + Args: + mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. + psi: The `TeNPy MPS `__ + wavefunction. + eng: The + `TeNPy TEBDEngine `__. + chi_list: The list to which to append the MPS bond dimensions as the circuit is + evaluated. + norm_tol: The norm error above which we recanonicalize the wavefunction, as + defined in the + `TeNPy documentation `__. + + Returns: + None + """ + + # extract norb + assert np.shape(mat)[1] == np.shape(mat)[2] + norb = np.shape(mat)[1] + + # unpack alpha-alpha and alpha-beta matrices + mat_aa, mat_ab = mat + + # apply alpha-alpha gates + for i in range(norb): + for j in range(norb): + if j > i and mat_aa[i, j]: + apply_gate2( + num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), + j, + psi, + eng, + chi_list, + norm_tol, + ) + + # apply alpha-beta gates + for i in range(norb): + apply_gate1(on_site_interaction(-mat_ab[i, i]), i, psi) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index c3b57013c..1a826a9ca 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -1,19 +1,12 @@ from __future__ import annotations import numpy as np -from qiskit.circuit import QuantumCircuit, QuantumRegister from tenpy.algorithms.tebd import TEBDEngine from tenpy.networks.mps import MPS -import ffsim -from ffsim.spin import Spin from ffsim.tenpy.circuits.gates import ( - gate1, - gate2, - givens_rotation, - num_interaction, - num_num_interaction, - on_site_interaction, + apply_diag_coulomb_evolution, + apply_orbital_rotation, ) from ffsim.tenpy.util import product_state_as_mps from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced @@ -21,7 +14,7 @@ def lucj_circuit_as_mps( norb: int, - nelec: tuple, + nelec: int | tuple[int, int], ucj_op: UCJOpSpinBalanced, options: dict, norm_tol: float = 1e-5, @@ -52,82 +45,20 @@ def lucj_circuit_as_mps( # prepare initial Hartree-Fock state psi = product_state_as_mps(norb, nelec, 0) - # construct the qiskit circuit - qubits = QuantumRegister(2 * norb) - circuit = QuantumCircuit(qubits) - circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(ucj_op), qubits) - # define the TEBD engine eng = TEBDEngine(psi, None, options) - # execute the tenpy circuit - for ins in circuit.decompose(reps=2): - if ins.operation.name == "p": - qubit = ins.qubits[0] - idx = qubit._index - spin_flag = Spin.ALPHA if idx < norb else Spin.BETA - lmbda = ins.operation.params[0] - gate1( - np.exp(1j * lmbda) * num_interaction(-lmbda, spin_flag), idx % norb, psi - ) - elif ins.operation.name == "xx_plus_yy": - qubit0 = ins.qubits[0] - qubit1 = ins.qubits[1] - idx0, idx1 = qubit0._index, qubit1._index - if idx0 < norb and idx1 < norb: - spin_flag = Spin.ALPHA - elif idx0 >= norb and idx1 >= norb: - spin_flag = Spin.BETA - else: - raise ValueError("XXPlusYY gate not allowed across spin sectors") - theta_val = ins.operation.params[0] - beta_val = ins.operation.params[1] - # directionality important when beta!=0 - conj_flag = True if idx0 > idx1 else False - gate2( - givens_rotation( - theta_val / 2, spin_flag, conj_flag, phi=beta_val - np.pi / 2 - ), - max(idx0 % norb, idx1 % norb), - psi, - eng, - chi_list, - norm_tol, - ) - elif ins.operation.name == "cp": - qubit0 = ins.qubits[0] - qubit1 = ins.qubits[1] - idx0, idx1 = qubit0._index, qubit1._index - lmbda = ins.operation.params[0] - # onsite (different spins) - if np.abs(idx0 - idx1) == norb: - gate1(on_site_interaction(-lmbda), min(idx0, idx1), psi) - # NN (up spins) - elif np.abs(idx0 - idx1) == 1 and idx0 < norb and idx1 < norb: - gate2( - num_num_interaction(-lmbda, Spin.ALPHA), - max(idx0, idx1), - psi, - eng, - chi_list, - norm_tol, - ) - # NN (down spins) - elif np.abs(idx0 - idx1) == 1 and idx0 >= norb and idx1 >= norb: - gate2( - num_num_interaction(-lmbda, Spin.BETA), - max(idx0 % norb, idx1 % norb), - psi, - eng, - chi_list, - norm_tol, - ) - else: - raise ValueError( - "CPhase only implemented onsite (different spins) " - "and NN (same spins)" - ) - else: - raise ValueError(f"gate {ins.operation.name} not implemented.") + # construct the LUCJ MPS + n_reps = np.shape(ucj_op.orbital_rotations)[0] + for i in range(n_reps): + apply_orbital_rotation( + np.conj(ucj_op.orbital_rotations[i]).T, psi, eng, chi_list, norm_tol + ) + apply_diag_coulomb_evolution( + ucj_op.diag_coulomb_mats[i], psi, eng, chi_list, norm_tol + ) + apply_orbital_rotation( + ucj_op.orbital_rotations[i], psi, eng, chi_list, norm_tol + ) return psi, chi_list diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 6b7fc2888..c683566d5 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -75,7 +75,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), - with_final_orbital_rotation=True, + with_final_orbital_rotation=False, ) params = rng.uniform(-10, 10, size=n_params) lucj_op = ffsim.UCJOpSpinBalanced.from_parameters( @@ -85,7 +85,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), - with_final_orbital_rotation=True, + with_final_orbital_rotation=False, ) # generate the corresponding LUCJ circuit From 0db2929c02618204a08a57c3c687e2dc02e7ef59 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 7 Nov 2024 16:00:47 +0100 Subject: [PATCH 33/88] add final_orbital_rotation --- docs/how-to-guides/lucj_mps.ipynb | 15 +++++++++++++-- python/ffsim/tenpy/circuits/lucj_circuit.py | 4 ++++ .../tenpy/hamiltonians/molecular_hamiltonian.py | 2 +- tests/python/tenpy/lucj_circuit_test.py | 4 ++-- 4 files changed, 20 insertions(+), 5 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 593d9c57b..2c998f449 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -380,10 +380,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.gridspec as gridspec\n", "\n", diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 1a826a9ca..931a73b7e 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -60,5 +60,9 @@ def lucj_circuit_as_mps( apply_orbital_rotation( ucj_op.orbital_rotations[i], psi, eng, chi_list, norm_tol ) + if ucj_op.final_orbital_rotation is not None: + apply_orbital_rotation( + ucj_op.final_orbital_rotation, psi, eng, chi_list, norm_tol + ) return psi, chi_list diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 16fb2974c..6df54f9a9 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -118,7 +118,7 @@ def from_molecular_hamiltonian( Rounding may reduce the MPO bond dimension. Returns: - The molecular Hamiltonian as a TeNPy MPOModel. + The molecular Hamiltonian as a `TeNPy MPOModel `__. """ if decimal_places: diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index c683566d5..6b7fc2888 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -75,7 +75,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), - with_final_orbital_rotation=False, + with_final_orbital_rotation=True, ) params = rng.uniform(-10, 10, size=n_params) lucj_op = ffsim.UCJOpSpinBalanced.from_parameters( @@ -85,7 +85,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), - with_final_orbital_rotation=False, + with_final_orbital_rotation=True, ) # generate the corresponding LUCJ circuit From 12263d555b77727d5ed909c47da4fc4f82136774 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 09:39:27 +0100 Subject: [PATCH 34/88] remove decimal_places argument of from_molecular_hamiltonian --- docs/how-to-guides/lucj_mps.ipynb | 95 ++++++------------- .../hamiltonians/molecular_hamiltonian.py | 22 +---- 2 files changed, 31 insertions(+), 86 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 2c998f449..c7020637d 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -34,23 +34,29 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp1e4pf6nc\n", - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", - "norb = 4\n", - "nelec = (2, 2)\n" + "Parsing /tmp/tmp310svyd6\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_hcore get_ovlp of \n", + "Overwritten attributes get_ovlp get_hcore of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", " warnings.warn(msg)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converged SCF energy = -77.8266321248745\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" + ] } ], "source": [ @@ -117,17 +123,17 @@ }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585367\n" + " does not have attributes converged\n" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " does not have attributes converged\n" + "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585392\n" ] } ], @@ -184,7 +190,7 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 58\n" + "maximum MPO bond dimension = 54\n" ] } ], @@ -200,55 +206,6 @@ "print(\"maximum MPO bond dimension = \", max(hamiltonian_mpo.chi))" ] }, - { - "cell_type": "markdown", - "id": "3fd02a8e-5675-4010-b24b-41259303e16c", - "metadata": {}, - "source": [ - "Optionally, we can pass the `decimal_places` argument to the `from_molecular_hamiltonian` method, which rounds the precision of the input one-body and two-body tensors. This reduces the MPO bond dimension at the expense of simulation accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "501c1a64-576d-48c9-9018-5e2053adddd5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from matplotlib.ticker import MaxNLocator\n", - "\n", - "dp_list = np.arange(1, 16, dtype=int)\n", - "chi_list = []\n", - "for dp in dp_list:\n", - " hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian(\n", - " mol_hamiltonian, decimal_places=dp\n", - " )\n", - " hamiltonian_mpo = hamiltonian_mpo_model.H_MPO\n", - " chi_list.append(max(hamiltonian_mpo.chi))\n", - "\n", - "fig = plt.figure()\n", - "ax = plt.subplot(111)\n", - "ax.plot(dp_list, chi_list, \".-\")\n", - "ax.set_xlabel(\"precision of one-body and two-body tensors / decimal places\")\n", - "ax.set_ylabel(\"maximum MPO bond dimension\")\n", - "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n", - "ax.grid(visible=True)\n", - "plt.show()" - ] - }, { "cell_type": "markdown", "id": "ad645d3446decfa8", @@ -271,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "e9d8e1b09ee778c2", "metadata": { "ExecuteTime": { @@ -294,6 +251,8 @@ } ], "source": [ + "import numpy as np\n", + "\n", "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", "\n", "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", @@ -323,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "a6a7d85060f3d8a2", "metadata": { "ExecuteTime": { @@ -336,9 +295,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77102667787551\n", + "LUCJ (MPS) energy = -77.77526490518737\n", "LUCJ energy = -77.84651018653345\n", - "FCI energy = -77.87421656438627\n" + "FCI energy = -77.8742165643863\n" ] } ], @@ -380,13 +339,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -397,6 +356,8 @@ ], "source": [ "import matplotlib.gridspec as gridspec\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator\n", "\n", "svd_min_list = [1e-3, 1e-6]\n", "chi_max_list = np.arange(2, 21, 2)\n", @@ -466,7 +427,7 @@ "id": "b2f8fbd2-b019-4d38-a4f1-62afcf238e3c", "metadata": {}, "source": [ - "From the above plots, we can see that above an MPS bond dimension of 16, the MPS representation of the LUCJ circuit is exact." + "From the above plots, we can see that at an MPS bond dimension of 16 or above, the MPS representation of the LUCJ circuit is exact." ] } ], diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 6df54f9a9..af95fd5e9 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -105,40 +105,24 @@ def init_terms(self, params): @staticmethod def from_molecular_hamiltonian( - molecular_hamiltonian: MolecularHamiltonian, decimal_places: int | None = None + molecular_hamiltonian: MolecularHamiltonian, ) -> MolecularHamiltonianMPOModel: r"""Convert MolecularHamiltonian to a MolecularHamiltonianMPOModel. Args: molecular_hamiltonian: The molecular Hamiltonian. - decimal_places: The number of decimal places to which to round the input - one-body and two-body tensors. - - .. note:: - Rounding may reduce the MPO bond dimension. Returns: The molecular Hamiltonian as a `TeNPy MPOModel `__. """ - if decimal_places: - one_body_tensor = np.round( - molecular_hamiltonian.one_body_tensor, decimals=decimal_places - ) - two_body_tensor = np.round( - molecular_hamiltonian.two_body_tensor, decimals=decimal_places - ) - else: - one_body_tensor = molecular_hamiltonian.one_body_tensor - two_body_tensor = molecular_hamiltonian.two_body_tensor - model_params = dict( cons_N="N", cons_Sz="Sz", L=1, norb=molecular_hamiltonian.norb, - one_body_tensor=one_body_tensor, - two_body_tensor=two_body_tensor, + one_body_tensor=molecular_hamiltonian.one_body_tensor, + two_body_tensor=molecular_hamiltonian.two_body_tensor, constant=molecular_hamiltonian.constant, ) mpo_model = MolecularHamiltonianMPOModel(model_params) From b8f35fbf0c9321ba0f7a5f6207c331d094ade9b1 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 09:49:14 +0100 Subject: [PATCH 35/88] fix final_orbital_rotation bug --- python/ffsim/tenpy/circuits/lucj_circuit.py | 8 ++-- tests/python/tenpy/lucj_circuit_test.py | 46 ++++++++++++++------- 2 files changed, 34 insertions(+), 20 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 931a73b7e..e4e614786 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -60,9 +60,9 @@ def lucj_circuit_as_mps( apply_orbital_rotation( ucj_op.orbital_rotations[i], psi, eng, chi_list, norm_tol ) - if ucj_op.final_orbital_rotation is not None: - apply_orbital_rotation( - ucj_op.final_orbital_rotation, psi, eng, chi_list, norm_tol - ) + if ucj_op.final_orbital_rotation is not None: + apply_orbital_rotation( + ucj_op.final_orbital_rotation, psi, eng, chi_list, norm_tol + ) return psi, chi_list diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 6b7fc2888..3e955b89b 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -38,23 +38,37 @@ def _interaction_pairs_spin_balanced_( @pytest.mark.parametrize( - "norb, nelec, connectivity", + "norb, nelec, n_reps, connectivity", [ - (4, (2, 2), "square"), - (4, (1, 2), "square"), - (4, (0, 2), "square"), - (4, (0, 0), "square"), - (4, (2, 2), "hex"), - (4, (1, 2), "hex"), - (4, (0, 2), "hex"), - (4, (0, 0), "hex"), - (4, (2, 2), "heavy-hex"), - (4, (1, 2), "heavy-hex"), - (4, (0, 2), "heavy-hex"), - (4, (0, 0), "heavy-hex"), + (4, (2, 2), 1, "square"), + (4, (1, 2), 1, "square"), + (4, (0, 2), 1, "square"), + (4, (0, 0), 1, "square"), + (4, (2, 2), 1, "hex"), + (4, (1, 2), 1, "hex"), + (4, (0, 2), 1, "hex"), + (4, (0, 0), 1, "hex"), + (4, (2, 2), 1, "heavy-hex"), + (4, (1, 2), 1, "heavy-hex"), + (4, (0, 2), 1, "heavy-hex"), + (4, (0, 0), 1, "heavy-hex"), + (4, (2, 2), 2, "square"), + (4, (1, 2), 2, "square"), + (4, (0, 2), 2, "square"), + (4, (0, 0), 2, "square"), + (4, (2, 2), 2, "hex"), + (4, (1, 2), 2, "hex"), + (4, (0, 2), 2, "hex"), + (4, (0, 0), 2, "hex"), + (4, (2, 2), 2, "heavy-hex"), + (4, (1, 2), 2, "heavy-hex"), + (4, (0, 2), 2, "heavy-hex"), + (4, (0, 0), 2, "heavy-hex"), ], ) -def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: str): +def test_lucj_circuit_as_mps( + norb: int, nelec: tuple[int, int], n_reps: int, connectivity: str +): """Test LUCJ circuit MPS construction.""" rng = np.random.default_rng() @@ -71,7 +85,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st # generate a random LUCJ ansatz n_params = ffsim.UCJOpSpinBalanced.n_params( norb=norb, - n_reps=1, + n_reps=n_reps, interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), @@ -81,7 +95,7 @@ def test_lucj_circuit_as_mps(norb: int, nelec: tuple[int, int], connectivity: st lucj_op = ffsim.UCJOpSpinBalanced.from_parameters( params, norb=norb, - n_reps=1, + n_reps=n_reps, interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), From 205b3c46876b6a649522d5fa51adfaecb6e8b4be Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 10:06:20 +0100 Subject: [PATCH 36/88] add zip loop in lucj_circuit --- python/ffsim/tenpy/circuits/gates.py | 10 ++++++++ python/ffsim/tenpy/circuits/lucj_circuit.py | 25 +++++++++++-------- python/ffsim/tenpy/hamiltonians/lattices.py | 10 ++++++++ .../hamiltonians/molecular_hamiltonian.py | 10 ++++++++ python/ffsim/tenpy/util.py | 10 ++++++++ 5 files changed, 54 insertions(+), 11 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 9175dbd24..85fae608e 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -1,3 +1,13 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + import numpy as np import scipy as sp import tenpy.linalg.np_conserved as npc diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index e4e614786..3215d1f2c 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -1,3 +1,13 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + from __future__ import annotations import numpy as np @@ -49,17 +59,10 @@ def lucj_circuit_as_mps( eng = TEBDEngine(psi, None, options) # construct the LUCJ MPS - n_reps = np.shape(ucj_op.orbital_rotations)[0] - for i in range(n_reps): - apply_orbital_rotation( - np.conj(ucj_op.orbital_rotations[i]).T, psi, eng, chi_list, norm_tol - ) - apply_diag_coulomb_evolution( - ucj_op.diag_coulomb_mats[i], psi, eng, chi_list, norm_tol - ) - apply_orbital_rotation( - ucj_op.orbital_rotations[i], psi, eng, chi_list, norm_tol - ) + for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): + apply_orbital_rotation(np.conj(orb_rot).T, psi, eng, chi_list, norm_tol) + apply_diag_coulomb_evolution(diag_mats, psi, eng, chi_list, norm_tol) + apply_orbital_rotation(orb_rot, psi, eng, chi_list, norm_tol) if ucj_op.final_orbital_rotation is not None: apply_orbital_rotation( ucj_op.final_orbital_rotation, psi, eng, chi_list, norm_tol diff --git a/python/ffsim/tenpy/hamiltonians/lattices.py b/python/ffsim/tenpy/hamiltonians/lattices.py index a60d79cfa..54059cba4 100644 --- a/python/ffsim/tenpy/hamiltonians/lattices.py +++ b/python/ffsim/tenpy/hamiltonians/lattices.py @@ -1,3 +1,13 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + import numpy as np from tenpy.models.lattice import Lattice diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index af95fd5e9..d4488861b 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -1,3 +1,13 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + from __future__ import annotations import numpy as np diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 7bc902fbb..d65a272fd 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -1,3 +1,13 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + from __future__ import annotations from tenpy.networks.mps import MPS From f2b9e9060a51e6281e008a6daec2727778382f40 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 10:31:48 +0100 Subject: [PATCH 37/88] add keyword-only arguments --- python/ffsim/tenpy/circuits/gates.py | 51 ++++++++++++--------- python/ffsim/tenpy/circuits/lucj_circuit.py | 19 ++++++-- 2 files changed, 44 insertions(+), 26 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 85fae608e..bb2b15e57 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -58,7 +58,7 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: def givens_rotation( - theta: float, spin: Spin, conj: bool = False, *, phi: float = 0.0 + theta: float, spin: Spin, *, conj: bool = False, phi: float = 0.0 ) -> np.ndarray: r"""The Givens rotation gate. @@ -258,18 +258,18 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: return NNgate_sym -def apply_gate1(U1: np.ndarray, site: int, psi: MPS) -> None: +def apply_gate1(psi: MPS, U1: np.ndarray, site: int) -> None: r"""Apply a single-site gate to a `TeNPy MPS `__ wavefunction. Args: + psi: The `TeNPy MPS `__ + wavefunction. U1: The single-site quantum gate. site: The gate will be applied to `site` on the `TeNPy MPS `__ wavefunction. - psi: The `TeNPy MPS `__ - wavefunction. Returns: None @@ -281,9 +281,10 @@ def apply_gate1(U1: np.ndarray, site: int, psi: MPS) -> None: def apply_gate2( + psi: MPS, U2: np.ndarray, site: int, - psi: MPS, + *, eng: TEBDEngine, chi_list: list, norm_tol: float = 1e-5, @@ -292,11 +293,11 @@ def apply_gate2( wavefunction. Args: + psi: The `TeNPy MPS `__ + wavefunction. U2: The two-site quantum gate. site: The gate will be applied to `(site-1, site)` on the `TeNPy MPS `__ wavefunction. - psi: The `TeNPy MPS `__ - wavefunction. eng: The `TeNPy TEBDEngine `__. chi_list: The list to which to append the MPS bond dimensions as the circuit is @@ -323,8 +324,9 @@ def apply_gate2( def apply_orbital_rotation( - mat: np.ndarray, psi: MPS, + mat: np.ndarray, + *, eng: TEBDEngine, chi_list: list, norm_tol: float = 1e-5, @@ -337,9 +339,9 @@ def apply_orbital_rotation( `apply_orbital_rotation `__. Args: - mat: The orbital rotation matrix of dimension `(norb, norb)`. psi: The `TeNPy MPS `__ wavefunction. + mat: The orbital rotation matrix of dimension `(norb, norb)`. eng: The `TeNPy TEBDEngine `__. chi_list: The list to which to append the MPS bond dimensions as the circuit is @@ -362,24 +364,29 @@ def apply_orbital_rotation( phi = np.real(1j * np.log(-s / np.sin(theta))) if theta else 0 conj = True if gate.j < gate.i else False apply_gate2( - givens_rotation(theta, Spin.ALPHA_AND_BETA, conj, phi=phi), - max(gate.i, gate.j), psi, - eng, - chi_list, - norm_tol, + givens_rotation(theta, Spin.ALPHA_AND_BETA, conj=conj, phi=phi), + max(gate.i, gate.j), + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, ) # apply the number interaction gates for i, z in enumerate(diag_mat): theta = float(np.angle(z)) apply_gate1( - np.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i, psi + psi, np.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i ) def apply_diag_coulomb_evolution( - mat: np.ndarray, psi: MPS, eng: TEBDEngine, chi_list: list, norm_tol: float = 1e-5 + psi: MPS, + mat: np.ndarray, + *, + eng: TEBDEngine, + chi_list: list, + norm_tol: float = 1e-5, ) -> None: r"""Apply a diagonal Coulomb evolution gate to a `TeNPy MPS `__ @@ -389,9 +396,9 @@ def apply_diag_coulomb_evolution( `apply_diag_coulomb_evolution `__. Args: - mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. psi: The `TeNPy MPS `__ wavefunction. + mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. eng: The `TeNPy TEBDEngine `__. chi_list: The list to which to append the MPS bond dimensions as the circuit is @@ -416,14 +423,14 @@ def apply_diag_coulomb_evolution( for j in range(norb): if j > i and mat_aa[i, j]: apply_gate2( + psi, num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), j, - psi, - eng, - chi_list, - norm_tol, + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, ) # apply alpha-beta gates for i in range(norb): - apply_gate1(on_site_interaction(-mat_ab[i, i]), i, psi) + apply_gate1(psi, on_site_interaction(-mat_ab[i, i]), i) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 3215d1f2c..4409ce584 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -27,6 +27,7 @@ def lucj_circuit_as_mps( nelec: int | tuple[int, int], ucj_op: UCJOpSpinBalanced, options: dict, + *, norm_tol: float = 1e-5, ) -> tuple[MPS, list[int]]: r"""Construct the LUCJ circuit as an MPS. @@ -60,12 +61,22 @@ def lucj_circuit_as_mps( # construct the LUCJ MPS for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): - apply_orbital_rotation(np.conj(orb_rot).T, psi, eng, chi_list, norm_tol) - apply_diag_coulomb_evolution(diag_mats, psi, eng, chi_list, norm_tol) - apply_orbital_rotation(orb_rot, psi, eng, chi_list, norm_tol) + apply_orbital_rotation( + psi, np.conj(orb_rot).T, eng=eng, chi_list=chi_list, norm_tol=norm_tol + ) + apply_diag_coulomb_evolution( + psi, diag_mats, eng=eng, chi_list=chi_list, norm_tol=norm_tol + ) + apply_orbital_rotation( + psi, orb_rot, eng=eng, chi_list=chi_list, norm_tol=norm_tol + ) if ucj_op.final_orbital_rotation is not None: apply_orbital_rotation( - ucj_op.final_orbital_rotation, psi, eng, chi_list, norm_tol + psi, + ucj_op.final_orbital_rotation, + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, ) return psi, chi_list From e99a1fd8d75c315f12ff54cbc833f0dd8e9c56d3 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 10:55:11 +0100 Subject: [PATCH 38/88] fix angles in orbital_rotation --- python/ffsim/tenpy/circuits/gates.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index bb2b15e57..d4b0b202d 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -8,6 +8,9 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +import cmath +import math + import numpy as np import scipy as sp import tenpy.linalg.np_conserved as npc @@ -359,9 +362,8 @@ def apply_orbital_rotation( # apply the Givens rotation gates for gate in givens_list: - theta = np.arccos(gate.c) - s = np.conj(gate.s) - phi = np.real(1j * np.log(-s / np.sin(theta))) if theta else 0 + theta = math.acos(gate.c) + phi = cmath.phase(gate.s) - np.pi conj = True if gate.j < gate.i else False apply_gate2( psi, From bdf583bcb24b5344e4566b82ce1c91c7516ef9f0 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 11:05:01 +0100 Subject: [PATCH 39/88] leverage current_basis in lucj_circuit_as_mps --- python/ffsim/tenpy/circuits/lucj_circuit.py | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 4409ce584..507d2b0d1 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -60,20 +60,31 @@ def lucj_circuit_as_mps( eng = TEBDEngine(psi, None, options) # construct the LUCJ MPS + current_basis = np.eye(norb) for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): apply_orbital_rotation( - psi, np.conj(orb_rot).T, eng=eng, chi_list=chi_list, norm_tol=norm_tol + psi, + np.conj(orb_rot).T @ current_basis, + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, ) apply_diag_coulomb_evolution( psi, diag_mats, eng=eng, chi_list=chi_list, norm_tol=norm_tol ) + current_basis = orb_rot + if ucj_op.final_orbital_rotation is None: apply_orbital_rotation( - psi, orb_rot, eng=eng, chi_list=chi_list, norm_tol=norm_tol + psi, + current_basis, + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, ) - if ucj_op.final_orbital_rotation is not None: + else: apply_orbital_rotation( psi, - ucj_op.final_orbital_rotation, + ucj_op.final_orbital_rotation @ current_basis, eng=eng, chi_list=chi_list, norm_tol=norm_tol, From 18ae3f3175eb0f391e85f09cc4b5d2b84a148abc Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 13:40:38 +0100 Subject: [PATCH 40/88] closed-form expressions for gates --- python/ffsim/tenpy/circuits/gates.py | 110 ++++++++++++++++----------- 1 file changed, 66 insertions(+), 44 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index d4b0b202d..c76cfcf34 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -12,7 +12,6 @@ import math import numpy as np -import scipy as sp import tenpy.linalg.np_conserved as npc from tenpy.algorithms.tebd import TEBDEngine from tenpy.linalg.charges import LegPipe @@ -26,7 +25,6 @@ # ruff: noqa: N803, N806 # define sites -shfs_nosym = SpinHalfFermionSite(cons_N=None, cons_Sz=None) shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") shfsc = LegPipe([shfs.leg, shfs.leg]) @@ -91,39 +89,53 @@ def givens_rotation( beta = -beta phi = beta - np.pi / 2 - # define operators - Id = shfs_nosym.get_op("Id").to_ndarray() - JW = shfs_nosym.get_op("JW").to_ndarray() - # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - Cdu = shfs_nosym.get_op("Cdu").to_ndarray() - Cu = shfs_nosym.get_op("Cu").to_ndarray() - JWu = shfs_nosym.get_op("JWu").to_ndarray() - Nu = shfs_nosym.get_op("Nu").to_ndarray() - # - Ggate_a = ( - np.kron(sp.linalg.expm(1j * phi * Nu), Id) - @ sp.linalg.expm( - theta * (np.kron(Cdu @ JW, Cu @ JWu) - np.kron(Cu @ JW, Cdu @ JWu)) - ) - @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) - ) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # Ggate_a = ( + # np.kron(sp.linalg.expm(1j * phi * Nu), Id) + # @ sp.linalg.expm( + # theta * (np.kron(Cdu @ JW, Cu @ JWu) - np.kron(Cu @ JW, Cdu @ JWu)) + # ) + # @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) + # ) + Ggate_a = np.eye(16, dtype=complex) + c = math.cos(theta) + for i in [1, 3, 4, 6, 9, 11, 12, 14]: + Ggate_a[i, i] = c + s = -cmath.exp(-1j * phi) * math.sin(theta) + Ggate_a[1, 4] = -s + Ggate_a[3, 6] = -s + Ggate_a[9, 12] = s + Ggate_a[11, 14] = s + Ggate_a[4, 1] = np.conj(s) + Ggate_a[6, 3] = np.conj(s) + Ggate_a[12, 9] = -np.conj(s) + Ggate_a[14, 11] = -np.conj(s) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - Cdd = shfs_nosym.get_op("Cdd").to_ndarray() - Cd = shfs_nosym.get_op("Cd").to_ndarray() - JWd = shfs_nosym.get_op("JWd").to_ndarray() - Nd = shfs_nosym.get_op("Nd").to_ndarray() - # - Ggate_b = ( - np.kron(sp.linalg.expm(1j * phi * Nd), Id) - @ sp.linalg.expm( - theta * (np.kron(Cdd @ JW, Cd @ JWd) - np.kron(Cd @ JW, Cdd @ JWd)) - ) - @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) - ) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # Ggate_b = ( + # np.kron(sp.linalg.expm(1j * phi * Nd), Id) + # @ sp.linalg.expm( + # theta * (np.kron(Cdd @ JW, Cd @ JWd) - np.kron(Cd @ JW, Cdd @ JWd)) + # ) + # @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) + # ) + Ggate_b = np.eye(16, dtype=complex) + c = math.cos(theta) + for i in [2, 3, 6, 7, 8, 9, 12, 13]: + Ggate_b[i, i] = c + s = -cmath.exp(-1j * phi) * math.sin(theta) + Ggate_b[2, 8] = -s + Ggate_b[3, 9] = s + Ggate_b[6, 12] = -s + Ggate_b[7, 13] = s + Ggate_b[8, 2] = np.conj(s) + Ggate_b[9, 3] = -np.conj(s) + Ggate_b[12, 6] = np.conj(s) + Ggate_b[13, 7] = -np.conj(s) # define total gate if spin is Spin.ALPHA: @@ -163,13 +175,19 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - Nu = shfs_nosym.get_op("Nu").to_ndarray() - Ngate_a = sp.linalg.expm(1j * theta * Nu) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # Ngate_a = sp.linalg.expm(1j * theta * Nu) + Ngate_a = np.eye(4, dtype=complex) + for i in [1, 3]: + Ngate_a[i, i] = np.exp(1j * theta) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - Nd = shfs_nosym.get_op("Nd").to_ndarray() - Ngate_b = sp.linalg.expm(1j * theta * Nd) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # Ngate_b = sp.linalg.expm(1j * theta * Nd) + Ngate_b = np.eye(4, dtype=complex) + for i in [2, 3]: + Ngate_b[i, i] = np.exp(1j * theta) # define total gate if spin is Spin.ALPHA: @@ -201,12 +219,10 @@ def on_site_interaction(theta: float) -> np.ndarray: The on-site interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - # define operators - Nu = shfs_nosym.get_op("Nu").to_ndarray() - Nd = shfs_nosym.get_op("Nd").to_ndarray() - - # define total gate - OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) + OSgate = np.eye(4, dtype=complex) + OSgate[3, 3] = np.exp(1j * theta) # convert to (N, Sz)-symmetry-conserved basis OSgate_sym = sym_cons_basis(OSgate) @@ -237,13 +253,19 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - Nu = shfs_nosym.get_op("Nu").to_ndarray() - NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) + NNgate_a = np.eye(16, dtype=complex) + for i in [5, 7, 13, 15]: + NNgate_a[i, i] = np.exp(1j * theta) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - Nd = shfs_nosym.get_op("Nd").to_ndarray() - NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) + # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) + NNgate_b = np.eye(16, dtype=complex) + for i in [10, 11, 14, 15]: + NNgate_b[i, i] = np.exp(1j * theta) # define total gate if spin is Spin.ALPHA: From d25d18d775251238820bc17d3cebf295e2ecc098 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 8 Nov 2024 13:48:19 +0100 Subject: [PATCH 41/88] remove flag from __init__ in MolecularHamiltonianMPOModel --- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index d4488861b..c11e92bbc 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -25,9 +25,6 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" def __init__(self, params): - if hasattr(self, "flag"): # only call __init__ once - return - self.flag = True CouplingMPOModel.__init__(self, params) def init_sites(self, params): From e387940d87c04f34c8f3bca0deae4a2c6bfd3d9c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 10 Nov 2024 16:32:06 +0100 Subject: [PATCH 42/88] delete __init__ method from MolecularHamiltonianMPOModel --- python/ffsim/tenpy/circuits/gates.py | 4 ++-- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 3 --- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index c76cfcf34..1806b9efe 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -300,7 +300,7 @@ def apply_gate1(psi: MPS, U1: np.ndarray, site: int) -> None: None """ - # on-site + # apply single-site gate U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) psi.apply_local_op(site, U1_npc) @@ -335,7 +335,7 @@ def apply_gate2( None """ - # bond between (site-1, site) + # apply NN gate between (site-1, site) U2_npc = npc.Array.from_ndarray( U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] ) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index c11e92bbc..af0569369 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -24,9 +24,6 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" - def __init__(self, params): - CouplingMPOModel.__init__(self, params) - def init_sites(self, params): cons_N = params.get("cons_N", "N") cons_Sz = params.get("cons_Sz", "Sz") From c9316656d06c02400ed1a1a222666ce563417594 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 10 Nov 2024 16:48:24 +0100 Subject: [PATCH 43/88] reduce numpy use --- python/ffsim/tenpy/circuits/gates.py | 40 +++++++++---------- python/ffsim/tenpy/circuits/lucj_circuit.py | 2 +- .../hamiltonians/molecular_hamiltonian.py | 3 +- tests/python/tenpy/lucj_circuit_test.py | 2 +- 4 files changed, 23 insertions(+), 24 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 1806b9efe..84ccc97f8 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -40,16 +40,16 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: """ # convert to (N, Sz)-symmetry-conserved basis - if np.shape(gate) == (4, 4): # 1-site gate + if gate.shape == (4, 4): # 1-site gate swap_list = [1, 3, 0, 2] - elif np.shape(gate) == (16, 16): # 2-site gate + elif gate.shape == (16, 16): # 2-site gate swap_list = [5, 11, 2, 7, 12, 15, 9, 14, 1, 6, 0, 3, 8, 13, 4, 10] else: raise ValueError( "only 1-site and 2-site gates implemented for symmetry basis conversion" ) - P = np.zeros(np.shape(gate)) + P = np.zeros(gate.shape) for i, s in enumerate(swap_list): P[i, s] = 1 @@ -108,10 +108,10 @@ def givens_rotation( Ggate_a[3, 6] = -s Ggate_a[9, 12] = s Ggate_a[11, 14] = s - Ggate_a[4, 1] = np.conj(s) - Ggate_a[6, 3] = np.conj(s) - Ggate_a[12, 9] = -np.conj(s) - Ggate_a[14, 11] = -np.conj(s) + Ggate_a[4, 1] = s.conjugate() + Ggate_a[6, 3] = s.conjugate() + Ggate_a[12, 9] = -s.conjugate() + Ggate_a[14, 11] = -s.conjugate() # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: @@ -132,10 +132,10 @@ def givens_rotation( Ggate_b[3, 9] = s Ggate_b[6, 12] = -s Ggate_b[7, 13] = s - Ggate_b[8, 2] = np.conj(s) - Ggate_b[9, 3] = -np.conj(s) - Ggate_b[12, 6] = np.conj(s) - Ggate_b[13, 7] = -np.conj(s) + Ggate_b[8, 2] = s.conjugate() + Ggate_b[9, 3] = -s.conjugate() + Ggate_b[12, 6] = s.conjugate() + Ggate_b[13, 7] = -s.conjugate() # define total gate if spin is Spin.ALPHA: @@ -179,7 +179,7 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: # Ngate_a = sp.linalg.expm(1j * theta * Nu) Ngate_a = np.eye(4, dtype=complex) for i in [1, 3]: - Ngate_a[i, i] = np.exp(1j * theta) + Ngate_a[i, i] = cmath.exp(1j * theta) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: @@ -187,7 +187,7 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: # Ngate_b = sp.linalg.expm(1j * theta * Nd) Ngate_b = np.eye(4, dtype=complex) for i in [2, 3]: - Ngate_b[i, i] = np.exp(1j * theta) + Ngate_b[i, i] = cmath.exp(1j * theta) # define total gate if spin is Spin.ALPHA: @@ -222,7 +222,7 @@ def on_site_interaction(theta: float) -> np.ndarray: # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) OSgate = np.eye(4, dtype=complex) - OSgate[3, 3] = np.exp(1j * theta) + OSgate[3, 3] = cmath.exp(1j * theta) # convert to (N, Sz)-symmetry-conserved basis OSgate_sym = sym_cons_basis(OSgate) @@ -257,7 +257,7 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: # NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) NNgate_a = np.eye(16, dtype=complex) for i in [5, 7, 13, 15]: - NNgate_a[i, i] = np.exp(1j * theta) + NNgate_a[i, i] = cmath.exp(1j * theta) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: @@ -265,7 +265,7 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: # NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) NNgate_b = np.eye(16, dtype=complex) for i in [10, 11, 14, 15]: - NNgate_b[i, i] = np.exp(1j * theta) + NNgate_b[i, i] = cmath.exp(1j * theta) # define total gate if spin is Spin.ALPHA: @@ -398,9 +398,9 @@ def apply_orbital_rotation( # apply the number interaction gates for i, z in enumerate(diag_mat): - theta = float(np.angle(z)) + theta = float(cmath.phase(z)) apply_gate1( - psi, np.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i + psi, cmath.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i ) @@ -436,8 +436,8 @@ def apply_diag_coulomb_evolution( """ # extract norb - assert np.shape(mat)[1] == np.shape(mat)[2] - norb = np.shape(mat)[1] + assert mat.shape[1] == mat.shape[2] + norb = mat.shape[1] # unpack alpha-alpha and alpha-beta matrices mat_aa, mat_ab = mat diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 507d2b0d1..899479243 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -64,7 +64,7 @@ def lucj_circuit_as_mps( for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): apply_orbital_rotation( psi, - np.conj(orb_rot).T @ current_basis, + orb_rot.conjugate().T @ current_basis, eng=eng, chi_list=chi_list, norm_tol=norm_tol, diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index af0569369..1215b24c8 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -129,6 +129,5 @@ def from_molecular_hamiltonian( two_body_tensor=molecular_hamiltonian.two_body_tensor, constant=molecular_hamiltonian.constant, ) - mpo_model = MolecularHamiltonianMPOModel(model_params) - return mpo_model + return MolecularHamiltonianMPOModel(model_params) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 3e955b89b..f25c1bcf0 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -114,6 +114,6 @@ def test_lucj_circuit_as_mps( wavefunction_mps, _ = lucj_circuit_as_mps(norb, nelec, lucj_op, options) # test expectation is preserved - original_expectation = np.real(np.vdot(lucj_state, hamiltonian @ lucj_state)) + original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(wavefunction_mps) np.testing.assert_allclose(original_expectation, mpo_expectation) From b40e4e39e7ab658c95fd573c14218095fc3fd842 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 10 Nov 2024 16:57:02 +0100 Subject: [PATCH 44/88] streamline sym_cons_basis --- python/ffsim/tenpy/circuits/gates.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 84ccc97f8..65533c9fa 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -41,21 +41,17 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: # convert to (N, Sz)-symmetry-conserved basis if gate.shape == (4, 4): # 1-site gate - swap_list = [1, 3, 0, 2] + # swap = [1, 3, 0, 2] + perm = [2, 0, 3, 1] elif gate.shape == (16, 16): # 2-site gate - swap_list = [5, 11, 2, 7, 12, 15, 9, 14, 1, 6, 0, 3, 8, 13, 4, 10] + # swap = [5, 11, 2, 7, 12, 15, 9, 14, 1, 6, 0, 3, 8, 13, 4, 10] + perm = [10, 8, 2, 11, 14, 0, 9, 3, 12, 6, 15, 1, 4, 13, 7, 5] else: raise ValueError( "only 1-site and 2-site gates implemented for symmetry basis conversion" ) - P = np.zeros(gate.shape) - for i, s in enumerate(swap_list): - P[i, s] = 1 - - gate_sym = P.T @ gate @ P - - return gate_sym + return gate[perm][:, perm] def givens_rotation( From 9fe8ed93c734f830f4a3b4b09140ddd230c26425 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 10 Nov 2024 17:05:51 +0100 Subject: [PATCH 45/88] remove unnecesary phase factor in apply_orbital_rotation --- python/ffsim/tenpy/circuits/gates.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 65533c9fa..8d3640016 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -395,9 +395,7 @@ def apply_orbital_rotation( # apply the number interaction gates for i, z in enumerate(diag_mat): theta = float(cmath.phase(z)) - apply_gate1( - psi, cmath.exp(1j * theta) * num_interaction(-theta, Spin.ALPHA_AND_BETA), i - ) + apply_gate1(psi, num_interaction(-theta, Spin.ALPHA_AND_BETA), i) def apply_diag_coulomb_evolution( From 994b651b9b04411a1c3c5b2f1a032201febc0ab1 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sun, 10 Nov 2024 17:45:22 +0100 Subject: [PATCH 46/88] get rid of conj argument for givens_rotation --- python/ffsim/tenpy/circuits/gates.py | 52 +++++++++++++--------------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 8d3640016..566d846b6 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -54,9 +54,7 @@ def sym_cons_basis(gate: np.ndarray) -> np.ndarray: return gate[perm][:, perm] -def givens_rotation( - theta: float, spin: Spin, *, conj: bool = False, phi: float = 0.0 -) -> np.ndarray: +def givens_rotation(theta: float, spin: Spin, *, phi: float = 0.0) -> np.ndarray: r"""The Givens rotation gate. The Givens rotation gate as defined in @@ -71,23 +69,15 @@ def givens_rotation( - To act on only spin beta, pass :const:`ffsim.Spin.BETA`. - To act on both spin alpha and spin beta, pass :const:`ffsim.Spin.ALPHA_AND_BETA`. - conj: The direction of the gate. By default, we use the little endian - convention, as in Qiskit. phi: The phase angle. Returns: The Givens rotation gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - # define conjugate phase - if conj: - beta = phi + np.pi / 2 - beta = -beta - phi = beta - np.pi / 2 - # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ggate_a = ( # np.kron(sp.linalg.expm(1j * phi * Nu), Id) # @ sp.linalg.expm( @@ -111,7 +101,7 @@ def givens_rotation( # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ggate_b = ( # np.kron(sp.linalg.expm(1j * phi * Nd), Id) # @ sp.linalg.expm( @@ -171,7 +161,7 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ngate_a = sp.linalg.expm(1j * theta * Nu) Ngate_a = np.eye(4, dtype=complex) for i in [1, 3]: @@ -179,7 +169,7 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ngate_b = sp.linalg.expm(1j * theta * Nd) Ngate_b = np.eye(4, dtype=complex) for i in [2, 3]: @@ -215,7 +205,7 @@ def on_site_interaction(theta: float) -> np.ndarray: The on-site interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) OSgate = np.eye(4, dtype=complex) OSgate[3, 3] = cmath.exp(1j * theta) @@ -249,7 +239,7 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) NNgate_a = np.eye(16, dtype=complex) for i in [5, 7, 13, 15]: @@ -257,7 +247,7 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: - # # Using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators + # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) NNgate_b = np.eye(16, dtype=complex) for i in [10, 11, 14, 15]: @@ -304,7 +294,7 @@ def apply_gate1(psi: MPS, U1: np.ndarray, site: int) -> None: def apply_gate2( psi: MPS, U2: np.ndarray, - site: int, + sites: tuple[int, int], *, eng: TEBDEngine, chi_list: list, @@ -317,7 +307,8 @@ def apply_gate2( psi: The `TeNPy MPS `__ wavefunction. U2: The two-site quantum gate. - site: The gate will be applied to `(site-1, site)` on the `TeNPy MPS `__ + sites: The gate will be applied to adjacent sites `(site1, site2)` on the + `TeNPy MPS `__ wavefunction. eng: The `TeNPy TEBDEngine `__. @@ -331,12 +322,20 @@ def apply_gate2( None """ - # apply NN gate between (site-1, site) + # check that sites are adjacent + if abs(sites[0] - sites[1]) != 1: + raise ValueError("sites must be adjacent") + + # check whether to transpose gate + if sites[0] > sites[1]: + U2 = U2.T + + # apply NN gate between (site1, site2) U2_npc = npc.Array.from_ndarray( U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] ) U2_npc_split = U2_npc.split_legs() - eng.update_bond(site, U2_npc_split) + eng.update_bond(max(sites), U2_npc_split) chi_list.append(psi.chi) # recanonicalize psi if below error threshold @@ -382,11 +381,10 @@ def apply_orbital_rotation( for gate in givens_list: theta = math.acos(gate.c) phi = cmath.phase(gate.s) - np.pi - conj = True if gate.j < gate.i else False apply_gate2( psi, - givens_rotation(theta, Spin.ALPHA_AND_BETA, conj=conj, phi=phi), - max(gate.i, gate.j), + givens_rotation(theta, Spin.ALPHA_AND_BETA, phi=phi), + (gate.i, gate.j), eng=eng, chi_list=chi_list, norm_tol=norm_tol, @@ -394,7 +392,7 @@ def apply_orbital_rotation( # apply the number interaction gates for i, z in enumerate(diag_mat): - theta = float(cmath.phase(z)) + theta = cmath.phase(z) apply_gate1(psi, num_interaction(-theta, Spin.ALPHA_AND_BETA), i) @@ -443,7 +441,7 @@ def apply_diag_coulomb_evolution( apply_gate2( psi, num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), - j, + (i, j), eng=eng, chi_list=chi_list, norm_tol=norm_tol, From 43aa2b255f89459b6b774cb8c0a41780fbb83e9e Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 12 Nov 2024 16:23:29 +0100 Subject: [PATCH 47/88] add test_apply_orbital_rotation --- tests/python/tenpy/lucj_circuit_test.py | 59 +++++++++++++++++++++++++ 1 file changed, 59 insertions(+) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index f25c1bcf0..879d6366a 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -10,13 +10,17 @@ """Tests for LUCJ circuit TeNPy methods.""" +from copy import deepcopy + import numpy as np import pytest from qiskit.circuit import QuantumCircuit, QuantumRegister +from tenpy.algorithms.tebd import TEBDEngine import ffsim from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.util import product_state_as_mps def _interaction_pairs_spin_balanced_( @@ -117,3 +121,58 @@ def test_lucj_circuit_as_mps( original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(wavefunction_mps) np.testing.assert_allclose(original_expectation, mpo_expectation) + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_apply_orbital_rotation( + norb: int, + nelec: tuple[int, int], +): + """Test applying orbital rotation to MPS.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + mps = product_state_as_mps(norb, nelec, idx) + original_mps = deepcopy(mps) + + # generate a random orbital rotation + mat = ffsim.random.random_unitary(norb, seed=rng) + + # apply random orbital rotation to state vector + vec = ffsim.apply_orbital_rotation(original_vec, mat, norb, nelec) + + # apply random orbital rotation to MPS + chi_list: list[int] = [] + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_orbital_rotation(mps, mat, eng=eng, chi_list=chi_list) + + # test matrix element is preserved + original_matrix_element = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) + mpo_matrix_element = mps.overlap(original_mps) + np.testing.assert_allclose(original_matrix_element, mpo_matrix_element) From e25a1d1b59d9bcd963492d7b7ec8693578806521 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 12 Nov 2024 16:32:59 +0100 Subject: [PATCH 48/88] fix norb definition --- python/ffsim/tenpy/circuits/gates.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index 566d846b6..b57a686d6 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -428,8 +428,7 @@ def apply_diag_coulomb_evolution( """ # extract norb - assert mat.shape[1] == mat.shape[2] - norb = mat.shape[1] + norb, _ = mat.shape # unpack alpha-alpha and alpha-beta matrices mat_aa, mat_ab = mat From 1e6858e7c4fc387c4e0d7cd80850d770b9746212 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 12 Nov 2024 17:12:08 +0100 Subject: [PATCH 49/88] remove MolecularChain class --- python/ffsim/tenpy/__init__.py | 2 -- python/ffsim/tenpy/circuits/gates.py | 2 +- python/ffsim/tenpy/hamiltonians/__init__.py | 2 -- python/ffsim/tenpy/hamiltonians/lattices.py | 31 ------------------- .../hamiltonians/molecular_hamiltonian.py | 14 +++++++-- 5 files changed, 13 insertions(+), 38 deletions(-) delete mode 100644 python/ffsim/tenpy/hamiltonians/lattices.py diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index bb0f692cf..4ab39946b 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -22,7 +22,6 @@ sym_cons_basis, ) from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps -from ffsim.tenpy.hamiltonians.lattices import MolecularChain from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import product_state_as_mps @@ -33,7 +32,6 @@ "apply_orbital_rotation", "givens_rotation", "lucj_circuit_as_mps", - "MolecularChain", "MolecularHamiltonianMPOModel", "num_interaction", "num_num_interaction", diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index b57a686d6..c6c62da8d 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -428,7 +428,7 @@ def apply_diag_coulomb_evolution( """ # extract norb - norb, _ = mat.shape + _, norb, _ = mat.shape # unpack alpha-alpha and alpha-beta matrices mat_aa, mat_ab = mat diff --git a/python/ffsim/tenpy/hamiltonians/__init__.py b/python/ffsim/tenpy/hamiltonians/__init__.py index 68bab34ba..d734edb66 100644 --- a/python/ffsim/tenpy/hamiltonians/__init__.py +++ b/python/ffsim/tenpy/hamiltonians/__init__.py @@ -10,10 +10,8 @@ """Classes for converting Hamiltonians to TeNPy MPOModel objects.""" -from ffsim.tenpy.hamiltonians.lattices import MolecularChain from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel __all__ = [ - "MolecularChain", "MolecularHamiltonianMPOModel", ] diff --git a/python/ffsim/tenpy/hamiltonians/lattices.py b/python/ffsim/tenpy/hamiltonians/lattices.py deleted file mode 100644 index 54059cba4..000000000 --- a/python/ffsim/tenpy/hamiltonians/lattices.py +++ /dev/null @@ -1,31 +0,0 @@ -# (C) Copyright IBM 2024. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -import numpy as np -from tenpy.models.lattice import Lattice - -# ignore lowercase argument checks to maintain TeNPy naming conventions -# ruff: noqa: N803 - - -class MolecularChain(Lattice): - """Molecular chain.""" - - def __init__(self, L, norb, site_a, **kwargs): - basis = np.array(([norb, 0.0], [0, 1])) - pos = np.array([[i, 0] for i in range(norb)]) - - kwargs.setdefault("order", "default") - kwargs.setdefault("bc", "open") - kwargs.setdefault("bc_MPS", "finite") - kwargs.setdefault("basis", basis) - kwargs.setdefault("positions", pos) - - super().__init__([L, 1], [site_a] * norb, **kwargs) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 1215b24c8..14714c1ad 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -11,11 +11,11 @@ from __future__ import annotations import numpy as np +from tenpy.models.lattice import Lattice from tenpy.models.model import CouplingMPOModel from tenpy.networks.site import SpinHalfFermionSite from ffsim.hamiltonians.molecular_hamiltonian import MolecularHamiltonian -from ffsim.tenpy.hamiltonians.lattices import MolecularChain # ignore lowercase variable checks to maintain TeNPy naming conventions # ruff: noqa: N806 @@ -34,7 +34,17 @@ def init_lattice(self, params): L = params.get("L", 1) norb = params.get("norb", 4) site = self.init_sites(params) - lat = MolecularChain(L, norb, site, basis=[[norb, 0], [0, 1]]) + basis = np.array(([norb, 0.0], [0, 1])) + pos = np.array([[i, 0] for i in range(norb)]) + lat = Lattice( + [L, 1], + [site] * norb, + order="default", + bc="open", + bc_MPS="finite", + basis=basis, + positions=pos, + ) return lat def init_terms(self, params): From 9fbdfc93f9ed77f05faf736649f4fc14b8138a86 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 12 Nov 2024 17:23:11 +0100 Subject: [PATCH 50/88] tidy lucj_circuit_test --- tests/python/tenpy/lucj_circuit_test.py | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 879d6366a..684c88937 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -14,7 +14,6 @@ import numpy as np import pytest -from qiskit.circuit import QuantumCircuit, QuantumRegister from tenpy.algorithms.tebd import TEBDEngine import ffsim @@ -87,31 +86,19 @@ def test_lucj_circuit_as_mps( mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO # generate a random LUCJ ansatz - n_params = ffsim.UCJOpSpinBalanced.n_params( - norb=norb, - n_reps=n_reps, - interaction_pairs=_interaction_pairs_spin_balanced_( - connectivity=connectivity, norb=norb - ), - with_final_orbital_rotation=True, - ) - params = rng.uniform(-10, 10, size=n_params) - lucj_op = ffsim.UCJOpSpinBalanced.from_parameters( - params, + lucj_op = ffsim.random.random_ucj_op_spin_balanced( norb=norb, n_reps=n_reps, interaction_pairs=_interaction_pairs_spin_balanced_( connectivity=connectivity, norb=norb ), with_final_orbital_rotation=True, + seed=rng, ) # generate the corresponding LUCJ circuit - qubits = QuantumRegister(2 * norb) - circuit = QuantumCircuit(qubits) - circuit.append(ffsim.qiskit.PrepareHartreeFockJW(norb, nelec), qubits) - circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_op), qubits) - lucj_state = ffsim.qiskit.final_state_vector(circuit).vec + lucj_state = ffsim.hartree_fock_state(norb, nelec) + lucj_state = ffsim.apply_unitary(lucj_state, lucj_op, norb, nelec) # convert LUCJ ansatz to MPS options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} From b9cf3a1b3cb5c535efc5d23a9f1b47bc5a52108c Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 12 Nov 2024 18:23:12 +0100 Subject: [PATCH 51/88] refactor bitstring_to_mps --- python/ffsim/tenpy/circuits/lucj_circuit.py | 11 ++++++++- python/ffsim/tenpy/util.py | 24 ++++++++----------- tests/python/tenpy/lucj_circuit_test.py | 9 ++++++- .../tenpy/molecular_hamiltonian_test.py | 9 ++++++- 4 files changed, 36 insertions(+), 17 deletions(-) diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 899479243..929677098 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -14,6 +14,7 @@ from tenpy.algorithms.tebd import TEBDEngine from tenpy.networks.mps import MPS +import ffsim from ffsim.tenpy.circuits.gates import ( apply_diag_coulomb_evolution, apply_orbital_rotation, @@ -54,7 +55,15 @@ def lucj_circuit_as_mps( chi_list: list[int] = [] # prepare initial Hartree-Fock state - psi = product_state_as_mps(norb, nelec, 0) + dim = ffsim.dim(norb, nelec) + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + psi = product_state_as_mps((strings_a[0], strings_b[0])) # define the TEBD engine eng = TEBDEngine(psi, None, options) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index d65a272fd..d094783d2 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -13,32 +13,27 @@ from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite -import ffsim - -def product_state_as_mps(norb: int, nelec: int | tuple[int, int], idx: int) -> MPS: +def product_state_as_mps(bitstring: tuple[str, str]) -> MPS: r"""Return the product state as an MPS. Args: - norb: The number of spatial orbitals. - nelec: The number of alpha and beta electrons. - idx: The index of the product state in the ffsim basis. + bitstring: The bitstring in the form `(string_a, string_b)`. Returns: The product state as an MPS. """ - dim = ffsim.dim(norb, nelec) - - strings = ffsim.addresses_to_strings( - range(dim), norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING - ) + # extract norb + assert len(bitstring[0]) == len(bitstring[1]) + norb = len(bitstring[0]) - string = strings[idx] - up_sector = list(string[0:norb].replace("1", "u")) - down_sector = list(string[norb : 2 * norb].replace("1", "d")) + # merge bitstrings + up_sector = list(bitstring[0].replace("1", "u")) + down_sector = list(bitstring[1].replace("1", "d")) product_state = list(map(lambda x, y: x + y, up_sector, down_sector)) + # relabel using TeNPy SpinHalfFermionSite convention for i, site in enumerate(product_state): if site == "00": product_state[i] = "empty" @@ -54,6 +49,7 @@ def product_state_as_mps(norb: int, nelec: int | tuple[int, int], idx: int) -> M # note that the bit positions increase from right to left product_state = product_state[::-1] + # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") psi_mps = MPS.from_product_state([shfs] * norb, product_state) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index 684c88937..a92bc664a 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -143,7 +143,14 @@ def test_apply_orbital_rotation( original_vec[idx] = 1 # convert random product state to MPS - mps = product_state_as_mps(norb, nelec, idx) + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = product_state_as_mps((strings_a[idx], strings_b[idx])) original_mps = deepcopy(mps) # generate a random orbital rotation diff --git a/tests/python/tenpy/molecular_hamiltonian_test.py b/tests/python/tenpy/molecular_hamiltonian_test.py index 543df4bb3..ea04c2c3f 100644 --- a/tests/python/tenpy/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/molecular_hamiltonian_test.py @@ -48,7 +48,14 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): product_state[idx] = 1 # convert product state to MPS - product_state_mps = product_state_as_mps(norb, nelec, idx) + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + product_state_mps = product_state_as_mps((strings_a[idx], strings_b[idx])) # test expectation is preserved original_expectation = np.vdot(product_state, hamiltonian @ product_state) From debce2321ec23758eeba8d6f0895e52c1fe7ecd9 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 14 Nov 2024 12:09:25 +0100 Subject: [PATCH 52/88] tidy MolecularHamiltonianMPOModel --- .../hamiltonians/molecular_hamiltonian.py | 121 +++++++++--------- 1 file changed, 61 insertions(+), 60 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 14714c1ad..6c540d687 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -10,6 +10,8 @@ from __future__ import annotations +import itertools + import numpy as np from tenpy.models.lattice import Lattice from tenpy.models.model import CouplingMPOModel @@ -56,66 +58,65 @@ def init_terms(self, params): ) constant = params.get("constant", 0) - for p in range(norb): - for q in range(norb): - h1 = one_body_tensor[q, p] - if p == q: - self.add_onsite(h1, p, "Nu") - self.add_onsite(h1, p, "Nd") - self.add_onsite(constant / norb, p, "Id") - else: - self.add_coupling(h1, p, "Cdu", q, "Cu", dx0) - self.add_coupling(h1, p, "Cdd", q, "Cd", dx0) - - for r in range(norb): - for s in range(norb): - h2 = two_body_tensor[q, p, s, r] - if p == q == r == s: - self.add_onsite(h2 / 2, p, "Nu") - self.add_onsite(-h2 / 2, p, "Nu Nu") - self.add_onsite(h2 / 2, p, "Nu") - self.add_onsite(-h2 / 2, p, "Cdu Cd Cdd Cu") - self.add_onsite(h2 / 2, p, "Nd") - self.add_onsite(-h2 / 2, p, "Cdd Cu Cdu Cd") - self.add_onsite(h2 / 2, p, "Nd") - self.add_onsite(-h2 / 2, p, "Nd Nd") - else: - self.add_multi_coupling( - h2 / 2, - [ - ("Cdu", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - h2 / 2, - [ - ("Cdu", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - h2 / 2, - [ - ("Cdd", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cd", dx0, q), - ], - ) - self.add_multi_coupling( - h2 / 2, - [ - ("Cdd", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cd", dx0, q), - ], - ) + for p, q in itertools.product(range(norb), repeat=2): + h1 = one_body_tensor[q, p] + if p == q: + self.add_onsite(h1, p, "Nu") + self.add_onsite(h1, p, "Nd") + self.add_onsite(constant / norb, p, "Id") + else: + self.add_coupling(h1, p, "Cdu", q, "Cu", dx0) + self.add_coupling(h1, p, "Cdd", q, "Cd", dx0) + + for r in range(norb): + for s in range(norb): + h2 = two_body_tensor[q, p, s, r] + if p == q == r == s: + self.add_onsite(0.5 * h2, p, "Nu") + self.add_onsite(-0.5 * h2, p, "Nu Nu") + self.add_onsite(0.5 * h2, p, "Nu") + self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") + self.add_onsite(0.5 * h2, p, "Nd") + self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") + self.add_onsite(0.5 * h2, p, "Nd") + self.add_onsite(-0.5 * h2, p, "Nd Nd") + else: + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cd", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cd", dx0, q), + ], + ) @staticmethod def from_molecular_hamiltonian( From dc7d07fc9abb41574260debca9b35b7eaca91388 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 14 Nov 2024 12:20:59 +0100 Subject: [PATCH 53/88] simplify for loops --- python/ffsim/tenpy/circuits/gates.py | 22 ++--- .../hamiltonians/molecular_hamiltonian.py | 97 +++++++++---------- 2 files changed, 59 insertions(+), 60 deletions(-) diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/circuits/gates.py index c6c62da8d..73fe44d7f 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/circuits/gates.py @@ -9,6 +9,7 @@ # that they have been altered from the originals. import cmath +import itertools import math import numpy as np @@ -434,17 +435,16 @@ def apply_diag_coulomb_evolution( mat_aa, mat_ab = mat # apply alpha-alpha gates - for i in range(norb): - for j in range(norb): - if j > i and mat_aa[i, j]: - apply_gate2( - psi, - num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), - (i, j), - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) + for i, j in itertools.product(range(norb), repeat=2): + if j > i and mat_aa[i, j]: + apply_gate2( + psi, + num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), + (i, j), + eng=eng, + chi_list=chi_list, + norm_tol=norm_tol, + ) # apply alpha-beta gates for i in range(norb): diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 6c540d687..0091adb87 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -68,55 +68,54 @@ def init_terms(self, params): self.add_coupling(h1, p, "Cdu", q, "Cu", dx0) self.add_coupling(h1, p, "Cdd", q, "Cd", dx0) - for r in range(norb): - for s in range(norb): - h2 = two_body_tensor[q, p, s, r] - if p == q == r == s: - self.add_onsite(0.5 * h2, p, "Nu") - self.add_onsite(-0.5 * h2, p, "Nu Nu") - self.add_onsite(0.5 * h2, p, "Nu") - self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") - self.add_onsite(0.5 * h2, p, "Nd") - self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") - self.add_onsite(0.5 * h2, p, "Nd") - self.add_onsite(-0.5 * h2, p, "Nd Nd") - else: - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cd", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cd", dx0, q), - ], - ) + for r, s in itertools.product(range(norb), repeat=2): + h2 = two_body_tensor[q, p, s, r] + if p == q == r == s: + self.add_onsite(0.5 * h2, p, "Nu") + self.add_onsite(-0.5 * h2, p, "Nu Nu") + self.add_onsite(0.5 * h2, p, "Nu") + self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") + self.add_onsite(0.5 * h2, p, "Nd") + self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") + self.add_onsite(0.5 * h2, p, "Nd") + self.add_onsite(-0.5 * h2, p, "Nd Nd") + else: + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cd", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cd", dx0, q), + ], + ) @staticmethod def from_molecular_hamiltonian( From 2e1777c4643721688e88472e804fa6d5ada3f5b2 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 14 Nov 2024 12:28:13 +0100 Subject: [PATCH 54/88] tidy product_state_as_mps utility function --- python/ffsim/tenpy/util.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index d094783d2..d33b82216 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -24,14 +24,17 @@ def product_state_as_mps(bitstring: tuple[str, str]) -> MPS: The product state as an MPS. """ + # unpack bitstrings + string_a, string_b = bitstring + # extract norb - assert len(bitstring[0]) == len(bitstring[1]) - norb = len(bitstring[0]) + assert len(string_a) == len(string_b) + norb = len(string_a) # merge bitstrings - up_sector = list(bitstring[0].replace("1", "u")) - down_sector = list(bitstring[1].replace("1", "d")) - product_state = list(map(lambda x, y: x + y, up_sector, down_sector)) + up_sector = string_a.replace("1", "u") + down_sector = string_b.replace("1", "d") + product_state = [a + b for a, b in zip(up_sector, down_sector)] # relabel using TeNPy SpinHalfFermionSite convention for i, site in enumerate(product_state): From c7dcc6b49576c5baae9687c3f2c9637fb5e44912 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 14 Nov 2024 16:56:57 +0100 Subject: [PATCH 55/88] rename lucj_circuit_as_mps to apply_ucj_op_spin_balanced --- docs/how-to-guides/lucj_mps.ipynb | 69 +++++++++++++++------ python/ffsim/tenpy/__init__.py | 4 +- python/ffsim/tenpy/circuits/lucj_circuit.py | 2 +- tests/python/tenpy/lucj_circuit_test.py | 6 +- 4 files changed, 55 insertions(+), 26 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index c7020637d..7151e86dc 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -29,34 +29,36 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/bart/TeNPy/tenpy/tools/optimization.py:317: UserWarning: Couldn't load compiled cython code. Code will run a bit slower.\n", + " warnings.warn(\"Couldn't load compiled cython code. Code will run a bit slower.\")\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp310svyd6\n" + "Parsing /tmp/tmps53l5ltg\n", + "converged SCF energy = -77.8266321248745\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_ovlp get_hcore of \n", + "Overwritten attributes get_hcore get_ovlp of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", " warnings.warn(msg)\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", - "norb = 4\n", - "nelec = (2, 2)\n" - ] } ], "source": [ @@ -123,17 +125,17 @@ }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " does not have attributes converged\n" + "E(CCSD) = -77.87421536374038 E_corr = -0.04758323886585217\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585392\n" + " does not have attributes converged\n" ] } ], @@ -295,8 +297,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77526490518737\n", - "LUCJ energy = -77.84651018653345\n", + "LUCJ (MPS) energy = -77.78472901487442\n", + "LUCJ energy = -77.84651018653344\n", "FCI energy = -77.8742165643863\n" ] } @@ -339,13 +341,39 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0 [1, 2, 1] [[1, 2, 1], [2, 2, 1], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 1], [2, 2, 2], [2, 2, 2]]\n", + "0 1 [4, 4, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 4, 4], [2, 4, 3], [2, 4, 3], [2, 4, 2], [2, 4, 2], [2, 4, 2], [4, 4, 2], [4, 4, 4], [4, 4, 4]]\n", + "0 2 [4, 6, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 6, 4], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [4, 6, 3], [4, 6, 4], [4, 6, 4]]\n", + "0 3 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 8, 4], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [4, 8, 3], [4, 8, 4], [4, 8, 4]]\n", + "0 4 [4, 10, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4]]\n", + "0 5 [4, 12, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4]]\n", + "0 6 [3, 9, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 11, 4], [3, 11, 4], [3, 11, 3], [3, 9, 3]]\n", + "0 7 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", + "0 8 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", + "0 9 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", + "1 0 [1, 2, 1] [[1, 2, 1], [2, 2, 1], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 1], [2, 2, 2], [2, 2, 2]]\n", + "1 1 [4, 4, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 4, 4], [2, 4, 3], [2, 4, 3], [2, 4, 2], [2, 4, 2], [2, 4, 2], [4, 4, 2], [4, 4, 4], [4, 4, 4]]\n", + "1 2 [4, 6, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 6, 4], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [4, 6, 3], [4, 6, 4], [4, 6, 4]]\n", + "1 3 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 8, 4], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [4, 8, 3], [4, 8, 4], [4, 8, 4]]\n", + "1 4 [4, 10, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4]]\n", + "1 5 [4, 12, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4]]\n", + "1 6 [4, 14, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4]]\n", + "1 7 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n", + "1 8 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n", + "1 9 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,6 +400,7 @@ " norb, nelec, lucj_operator, options, norm_tol=1e-5\n", " )\n", " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", + " print(i, j, psi_mps.chi, chi_list)\n", " max_chi[i, j] = np.max(chi_list)\n", "\n", "fig = plt.figure(figsize=(10, 4))\n", diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 4ab39946b..142765ba8 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -21,17 +21,17 @@ on_site_interaction, sym_cons_basis, ) -from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps +from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import product_state_as_mps __all__ = [ + "apply_ucj_op_spin_balanced", "apply_diag_coulomb_evolution", "apply_gate1", "apply_gate2", "apply_orbital_rotation", "givens_rotation", - "lucj_circuit_as_mps", "MolecularHamiltonianMPOModel", "num_interaction", "num_num_interaction", diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 929677098..0d28f3c24 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -23,7 +23,7 @@ from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced -def lucj_circuit_as_mps( +def apply_ucj_op_spin_balanced( norb: int, nelec: int | tuple[int, int], ucj_op: UCJOpSpinBalanced, diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index a92bc664a..e8308e6c6 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -17,7 +17,7 @@ from tenpy.algorithms.tebd import TEBDEngine import ffsim -from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps +from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import product_state_as_mps @@ -69,7 +69,7 @@ def _interaction_pairs_spin_balanced_( (4, (0, 0), 2, "heavy-hex"), ], ) -def test_lucj_circuit_as_mps( +def test_apply_ucj_op_spin_balanced( norb: int, nelec: tuple[int, int], n_reps: int, connectivity: str ): """Test LUCJ circuit MPS construction.""" @@ -102,7 +102,7 @@ def test_lucj_circuit_as_mps( # convert LUCJ ansatz to MPS options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - wavefunction_mps, _ = lucj_circuit_as_mps(norb, nelec, lucj_op, options) + wavefunction_mps, _ = apply_ucj_op_spin_balanced(norb, nelec, lucj_op, options) # test expectation is preserved original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real From 3207948887a8e6c3c560bcd9984187c5ed628782 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 14 Nov 2024 17:10:59 +0100 Subject: [PATCH 56/88] fix notebook --- docs/how-to-guides/lucj_mps.ipynb | 55 ++++++--------------- python/ffsim/tenpy/circuits/lucj_circuit.py | 2 +- tests/python/tenpy/lucj_circuit_test.py | 2 +- 3 files changed, 16 insertions(+), 43 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 7151e86dc..cb5296317 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -42,9 +42,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmps53l5ltg\n", + "Parsing /tmp/tmpcz7vv5ks\n", "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -53,7 +53,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_hcore get_ovlp of \n", + "Overwritten attributes get_ovlp get_hcore of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -128,7 +128,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374038 E_corr = -0.04758323886585217\n" + "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585139\n" ] }, { @@ -255,11 +255,11 @@ "source": [ "import numpy as np\n", "\n", - "from ffsim.tenpy.circuits.lucj_circuit import lucj_circuit_as_mps\n", + "from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced\n", "\n", "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", - "psi_mps, chi_list = lucj_circuit_as_mps(\n", - " norb, nelec, lucj_operator, options, norm_tol=1e-5\n", + "psi_mps, chi_list = apply_ucj_op_spin_balanced(\n", + " lucj_operator, norb, nelec, options, norm_tol=1e-5\n", ")\n", "print(\"wavefunction type = \", type(psi_mps))\n", "print(psi_mps)\n", @@ -297,9 +297,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.78472901487442\n", - "LUCJ energy = -77.84651018653344\n", - "FCI energy = -77.8742165643863\n" + "LUCJ (MPS) energy = -77.77102552350503\n", + "LUCJ energy = -77.84651018653352\n", + "FCI energy = -77.87421656438629\n" ] } ], @@ -341,39 +341,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "bf98d538-c182-4ede-917f-1eed31969c9a", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 0 [1, 2, 1] [[1, 2, 1], [2, 2, 1], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 1], [2, 2, 2], [2, 2, 2]]\n", - "0 1 [4, 4, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 4, 4], [2, 4, 3], [2, 4, 3], [2, 4, 2], [2, 4, 2], [2, 4, 2], [4, 4, 2], [4, 4, 4], [4, 4, 4]]\n", - "0 2 [4, 6, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 6, 4], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [4, 6, 3], [4, 6, 4], [4, 6, 4]]\n", - "0 3 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 8, 4], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [4, 8, 3], [4, 8, 4], [4, 8, 4]]\n", - "0 4 [4, 10, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4]]\n", - "0 5 [4, 12, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4]]\n", - "0 6 [3, 9, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 11, 4], [3, 11, 4], [3, 11, 3], [3, 9, 3]]\n", - "0 7 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", - "0 8 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", - "0 9 [3, 4, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 12, 4], [3, 12, 4], [3, 12, 3], [3, 4, 3]]\n", - "1 0 [1, 2, 1] [[1, 2, 1], [2, 2, 1], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 1], [2, 2, 2], [2, 2, 2]]\n", - "1 1 [4, 4, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 4, 4], [2, 4, 3], [2, 4, 3], [2, 4, 2], [2, 4, 2], [2, 4, 2], [4, 4, 2], [4, 4, 4], [4, 4, 4]]\n", - "1 2 [4, 6, 3] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 6, 4], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [3, 6, 3], [4, 6, 3], [4, 6, 4], [4, 6, 4]]\n", - "1 3 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 8, 4], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [3, 8, 3], [4, 8, 3], [4, 8, 4], [4, 8, 4]]\n", - "1 4 [4, 10, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4], [4, 10, 4]]\n", - "1 5 [4, 12, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4], [4, 12, 4]]\n", - "1 6 [4, 14, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4], [4, 14, 4]]\n", - "1 7 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n", - "1 8 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n", - "1 9 [4, 8, 4] [[1, 4, 1], [4, 4, 1], [4, 4, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 16, 4], [4, 8, 4]]\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -396,11 +370,10 @@ " options[\"trunc_params\"][\"svd_min\"] = svd_min\n", " for j, chi_max in enumerate(chi_max_list):\n", " options[\"trunc_params\"][\"chi_max\"] = int(chi_max)\n", - " psi_mps, chi_list = lucj_circuit_as_mps(\n", - " norb, nelec, lucj_operator, options, norm_tol=1e-5\n", + " psi_mps, chi_list = apply_ucj_op_spin_balanced(\n", + " lucj_operator, norb, nelec, options, norm_tol=1e-5\n", " )\n", " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", - " print(i, j, psi_mps.chi, chi_list)\n", " max_chi[i, j] = np.max(chi_list)\n", "\n", "fig = plt.figure(figsize=(10, 4))\n", diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py index 0d28f3c24..3b6ca8fe9 100644 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ b/python/ffsim/tenpy/circuits/lucj_circuit.py @@ -24,9 +24,9 @@ def apply_ucj_op_spin_balanced( + ucj_op: UCJOpSpinBalanced, norb: int, nelec: int | tuple[int, int], - ucj_op: UCJOpSpinBalanced, options: dict, *, norm_tol: float = 1e-5, diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py index e8308e6c6..d334e4c0f 100644 --- a/tests/python/tenpy/lucj_circuit_test.py +++ b/tests/python/tenpy/lucj_circuit_test.py @@ -102,7 +102,7 @@ def test_apply_ucj_op_spin_balanced( # convert LUCJ ansatz to MPS options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - wavefunction_mps, _ = apply_ucj_op_spin_balanced(norb, nelec, lucj_op, options) + wavefunction_mps, _ = apply_ucj_op_spin_balanced(lucj_op, norb, nelec, options) # test expectation is preserved original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real From 1300a132dfbfbeaa6b052bf4903fd2b2e434bf94 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 15 Nov 2024 17:11:25 +0100 Subject: [PATCH 57/88] major gate refactoring --- docs/how-to-guides/lucj_mps.ipynb | 107 +++++---- python/ffsim/tenpy/__init__.py | 16 +- python/ffsim/tenpy/circuits/lucj_circuit.py | 102 --------- .../tenpy/{circuits => gates}/__init__.py | 0 python/ffsim/tenpy/gates/abstract_gates.py | 81 +++++++ .../gates.py => gates/basic_gates.py} | 206 +----------------- python/ffsim/tenpy/gates/diag_coulomb.py | 59 +++++ python/ffsim/tenpy/gates/orbital_rotation.py | 60 +++++ python/ffsim/tenpy/gates/ucj.py | 62 ++++++ python/ffsim/tenpy/util.py | 10 +- python/ffsim/testing/__init__.py | 2 + python/ffsim/testing/testing.py | 18 ++ tests/python/tenpy/gates/__init__.py | 9 + .../tenpy/gates/orbital_rotation_test.py | 82 +++++++ tests/python/tenpy/gates/ucj_test.py | 101 +++++++++ tests/python/tenpy/hamiltonians/__init__.py | 9 + .../molecular_hamiltonian_test.py | 4 +- tests/python/tenpy/lucj_circuit_test.py | 172 --------------- 18 files changed, 564 insertions(+), 536 deletions(-) delete mode 100644 python/ffsim/tenpy/circuits/lucj_circuit.py rename python/ffsim/tenpy/{circuits => gates}/__init__.py (100%) create mode 100644 python/ffsim/tenpy/gates/abstract_gates.py rename python/ffsim/tenpy/{circuits/gates.py => gates/basic_gates.py} (53%) create mode 100644 python/ffsim/tenpy/gates/diag_coulomb.py create mode 100644 python/ffsim/tenpy/gates/orbital_rotation.py create mode 100644 python/ffsim/tenpy/gates/ucj.py create mode 100644 tests/python/tenpy/gates/__init__.py create mode 100644 tests/python/tenpy/gates/orbital_rotation_test.py create mode 100644 tests/python/tenpy/gates/ucj_test.py create mode 100644 tests/python/tenpy/hamiltonians/__init__.py rename tests/python/tenpy/{ => hamiltonians}/molecular_hamiltonian_test.py (94%) delete mode 100644 tests/python/tenpy/lucj_circuit_test.py diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index cb5296317..c204e4da3 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -42,9 +42,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmpcz7vv5ks\n", - "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", + "Parsing /tmp/tmpzfgzc02x\n", + "converged SCF energy = -77.8266321248744\n", + "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -53,7 +53,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_ovlp get_hcore of \n", + "Overwritten attributes get_hcore get_ovlp of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -128,7 +128,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585139\n" + "E(CCSD) = -77.87421536374035 E_corr = -0.0475832388658516\n" ] }, { @@ -225,7 +225,7 @@ "\n", "We can pass the `options` dictionary and `norm_tol` to the `lucj_circuit_as_mps` function to control the accuracy of our MPS approximation. The `options` parameter is detailed in the [TeNPy TEBDEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.tebd.TEBDEngine.html#tenpy.algorithms.tebd.TEBDEngine). The `norm_tol` parameter is defined in other contexts in the TeNPy library, e.g. in the [TeNPy DMRGEngine documentation](https://tenpy.readthedocs.io/en/latest/reference/tenpy.algorithms.dmrg.DMRGEngine.html#cfg-option-DMRGEngine.norm_tol). The most relevant key for us in the `options` dictionary is `trunc_params`, which defines the truncation parameters for our quantum circuit. In particular, `chi_max` sets the maximum bond dimension, and `svd_min` sets the minimum Schmidt value cutoff. We also introduce the `norm_tol` parameter, which sets the maximum norm error above which the wavefunction is recanonicalized.\n", "\n", - "In addition to the wavefunction as an MPS, the `lucj_circuit_as_mps` function also returns `chi_list`, which is a list of MPS bond dimensions that is stored after each two-site gate is applied to our initial Hartree-Fock state. This gives us an indication of how the entanglement grows in the system as we run our circuit. In the example below, we set the maximum allowed bond dimension to 15, and after running the circuit, we can see that the maximum bond dimension reaches 15. This indicates that we have most likely truncated the bond dimension with our choice of `chi_max`." + "In the example below, we set the maximum allowed bond dimension to 15, and after running the circuit, we can see that the maximum bond dimension reaches 15. This indicates that we have most likely truncated the bond dimension with our choice of `chi_max`." ] }, { @@ -247,23 +247,40 @@ "MPS, L=4, bc='finite'.\n", "chi: [4, 15, 4]\n", "sites: SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000) SpinHalfFermionSite('N', 'Sz', 1.000000)\n", - "forms: (0.0, 1.0) (0.0, 1.0) (0.0, 1.0) (0.0, 1.0)\n", - "maximum MPS bond dimension = 15\n" + "forms: (0.0, 1.0) (0.0, 1.0) (0.0, 1.0) (0.0, 1.0)\n" ] } ], "source": [ "import numpy as np\n", + "from tenpy.algorithms.tebd import TEBDEngine\n", "\n", - "from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced\n", + "import ffsim\n", + "from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced\n", + "from ffsim.tenpy.util import bitstring_to_mps\n", "\n", - "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", - "psi_mps, chi_list = apply_ucj_op_spin_balanced(\n", - " lucj_operator, norb, nelec, options, norm_tol=1e-5\n", + "# Construct Hartree-Fock state\n", + "dim = ffsim.dim(norb, nelec)\n", + "strings_a, strings_b = ffsim.addresses_to_strings(\n", + " range(dim),\n", + " norb=norb,\n", + " nelec=nelec,\n", + " bitstring_type=ffsim.BitstringType.STRING,\n", + " concatenate=False,\n", ")\n", + "psi_mps = bitstring_to_mps((strings_a[0], strings_b[0]))\n", + "\n", + "# Construct the TEBD engine\n", + "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", + "eng = TEBDEngine(psi_mps, None, options)\n", + "\n", + "# Apply the LUCJ operator\n", + "apply_ucj_op_spin_balanced(eng, lucj_operator)\n", + "\n", + "# Print the wavefunction\n", + "psi_mps = eng.get_resume_data()[\"psi\"]\n", "print(\"wavefunction type = \", type(psi_mps))\n", - "print(psi_mps)\n", - "print(\"maximum MPS bond dimension = \", np.max(chi_list))" + "print(psi_mps)" ] }, { @@ -297,28 +314,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77102552350503\n", - "LUCJ energy = -77.84651018653352\n", - "FCI energy = -77.87421656438629\n" + "LUCJ (MPS) energy = -77.77102552350492\n", + "LUCJ energy = -77.84651018653346\n", + "FCI energy = -77.87421656438624\n" ] } ], "source": [ - "import numpy as np\n", - "from qiskit.circuit import QuantumCircuit, QuantumRegister\n", - "\n", "# Compute the LUCJ (MPS) energy\n", "lucj_mps_energy = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", "print(\"LUCJ (MPS) energy = \", lucj_mps_energy)\n", "\n", "# Compute the LUCJ energy\n", - "qubits = QuantumRegister(2 * norb)\n", - "circuit = QuantumCircuit(qubits)\n", - "circuit.append(ffsim.qiskit.PrepareHartreeFockJW(norb, nelec), qubits)\n", - "circuit.append(ffsim.qiskit.UCJOpSpinBalancedJW(lucj_operator), qubits)\n", - "lucj_state = ffsim.qiskit.final_state_vector(circuit).vec\n", - "hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb=norb, nelec=nelec)\n", - "lucj_energy = np.real(np.vdot(lucj_state, hamiltonian @ lucj_state))\n", + "hf_state = ffsim.hartree_fock_state(norb, nelec)\n", + "lucj_state = ffsim.apply_unitary(hf_state, lucj_operator, norb, nelec)\n", + "hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec)\n", + "lucj_energy = np.vdot(lucj_state, hamiltonian @ lucj_state).real\n", "print(\"LUCJ energy = \", lucj_energy)\n", "\n", "# Print the FCI energy\n", @@ -347,7 +358,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -357,6 +368,8 @@ } ], "source": [ + "from copy import deepcopy\n", + "\n", "import matplotlib.gridspec as gridspec\n", "import matplotlib.pyplot as plt\n", "from matplotlib.ticker import MaxNLocator\n", @@ -364,17 +377,26 @@ "svd_min_list = [1e-3, 1e-6]\n", "chi_max_list = np.arange(2, 21, 2)\n", "lucj_mps_energy = np.zeros((2, len(chi_max_list)))\n", - "max_chi = np.zeros((2, len(chi_max_list)))\n", "\n", + "# Construct Hartree-Fock state\n", + "dim = ffsim.dim(norb, nelec)\n", + "strings_a, strings_b = ffsim.addresses_to_strings(\n", + " range(dim),\n", + " norb=norb,\n", + " nelec=nelec,\n", + " bitstring_type=ffsim.BitstringType.STRING,\n", + " concatenate=False,\n", + ")\n", + "initial_mps = bitstring_to_mps((strings_a[0], strings_b[0]))\n", + "\n", + "# Loop over cutoff and bond dimension\n", "for i, svd_min in enumerate(svd_min_list):\n", - " options[\"trunc_params\"][\"svd_min\"] = svd_min\n", " for j, chi_max in enumerate(chi_max_list):\n", - " options[\"trunc_params\"][\"chi_max\"] = int(chi_max)\n", - " psi_mps, chi_list = apply_ucj_op_spin_balanced(\n", - " lucj_operator, norb, nelec, options, norm_tol=1e-5\n", - " )\n", - " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(psi_mps)\n", - " max_chi[i, j] = np.max(chi_list)\n", + " final_mps = deepcopy(initial_mps)\n", + " options = {\"trunc_params\": {\"chi_max\": int(chi_max), \"svd_min\": svd_min}}\n", + " eng = TEBDEngine(final_mps, None, options)\n", + " apply_ucj_op_spin_balanced(eng, lucj_operator)\n", + " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(final_mps)\n", "\n", "fig = plt.figure(figsize=(10, 4))\n", "gs = gridspec.GridSpec(1, 2, wspace=0.3)\n", @@ -388,12 +410,6 @@ " \".-\",\n", " label=f\"$\\\\lambda_\\\\text{{min}}=10^{{{np.log10(svd_min_list[i]):g}}}$\",\n", " )\n", - " ax0.axvline(\n", - " x=np.max(max_chi[i, :]),\n", - " c=f\"C{i}\",\n", - " linestyle=\"dashed\",\n", - " label=f\"$\\\\chi_\\\\text{{max}}(10^{{{np.log10(svd_min_list[i]):g}}})$\",\n", - " )\n", "\n", "ax0.set_xlabel(\"maximum MPS bond dimension\")\n", "ax0.set_ylabel(\"$E$\")\n", @@ -409,12 +425,7 @@ " \".-\",\n", " label=f\"$\\\\lambda_\\\\text{{min}}=10^{{{np.log10(svd_min_list[i]):g}}}$\",\n", " )\n", - " ax1.axvline(\n", - " x=np.max(max_chi[i, :]),\n", - " c=f\"C{i}\",\n", - " linestyle=\"dashed\",\n", - " label=f\"$\\\\chi_\\\\text{{max}}(10^{{{np.log10(svd_min_list[i]):g}}})$\",\n", - " )\n", + "\n", "ax1.set_xlabel(\"maximum MPS bond dimension\")\n", "ax1.set_ylabel(\"$|E-E_\\\\text{LUCJ}|$\")\n", "ax1.xaxis.set_major_locator(MaxNLocator(integer=True))\n", diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 142765ba8..d72ec1ec4 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -10,20 +10,21 @@ """Code that uses TeNPy, e.g. for emulating quantum circuits.""" -from ffsim.tenpy.circuits.gates import ( - apply_diag_coulomb_evolution, +from ffsim.tenpy.gates.abstract_gates import ( apply_gate1, apply_gate2, - apply_orbital_rotation, +) +from ffsim.tenpy.gates.basic_gates import ( givens_rotation, num_interaction, num_num_interaction, on_site_interaction, - sym_cons_basis, ) -from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced +from ffsim.tenpy.gates.diag_coulomb import apply_diag_coulomb_evolution +from ffsim.tenpy.gates.orbital_rotation import apply_orbital_rotation +from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import product_state_as_mps +from ffsim.tenpy.util import bitstring_to_mps __all__ = [ "apply_ucj_op_spin_balanced", @@ -31,11 +32,10 @@ "apply_gate1", "apply_gate2", "apply_orbital_rotation", + "bitstring_to_mps", "givens_rotation", "MolecularHamiltonianMPOModel", "num_interaction", "num_num_interaction", "on_site_interaction", - "product_state_as_mps", - "sym_cons_basis", ] diff --git a/python/ffsim/tenpy/circuits/lucj_circuit.py b/python/ffsim/tenpy/circuits/lucj_circuit.py deleted file mode 100644 index 3b6ca8fe9..000000000 --- a/python/ffsim/tenpy/circuits/lucj_circuit.py +++ /dev/null @@ -1,102 +0,0 @@ -# (C) Copyright IBM 2024. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -from __future__ import annotations - -import numpy as np -from tenpy.algorithms.tebd import TEBDEngine -from tenpy.networks.mps import MPS - -import ffsim -from ffsim.tenpy.circuits.gates import ( - apply_diag_coulomb_evolution, - apply_orbital_rotation, -) -from ffsim.tenpy.util import product_state_as_mps -from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced - - -def apply_ucj_op_spin_balanced( - ucj_op: UCJOpSpinBalanced, - norb: int, - nelec: int | tuple[int, int], - options: dict, - *, - norm_tol: float = 1e-5, -) -> tuple[MPS, list[int]]: - r"""Construct the LUCJ circuit as an MPS. - - Args: - norb: The number of spatial orbitals. - nelec: The number of alpha and beta electrons. - ucj_op: The LUCJ operator. - options: The options parsed by the - `TeNPy TEBDEngine `__. - norm_tol: The norm error above which we recanonicalize the wavefunction, as - defined in the - `TeNPy documentation `__. - - Returns: - `TeNPy MPS `__ - LUCJ circuit as an MPS. - - list[int] - Complete list of MPS bond dimensions compiled during circuit evaluation. - """ - - # initialize chi_list - chi_list: list[int] = [] - - # prepare initial Hartree-Fock state - dim = ffsim.dim(norb, nelec) - strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - psi = product_state_as_mps((strings_a[0], strings_b[0])) - - # define the TEBD engine - eng = TEBDEngine(psi, None, options) - - # construct the LUCJ MPS - current_basis = np.eye(norb) - for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): - apply_orbital_rotation( - psi, - orb_rot.conjugate().T @ current_basis, - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) - apply_diag_coulomb_evolution( - psi, diag_mats, eng=eng, chi_list=chi_list, norm_tol=norm_tol - ) - current_basis = orb_rot - if ucj_op.final_orbital_rotation is None: - apply_orbital_rotation( - psi, - current_basis, - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) - else: - apply_orbital_rotation( - psi, - ucj_op.final_orbital_rotation @ current_basis, - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) - - return psi, chi_list diff --git a/python/ffsim/tenpy/circuits/__init__.py b/python/ffsim/tenpy/gates/__init__.py similarity index 100% rename from python/ffsim/tenpy/circuits/__init__.py rename to python/ffsim/tenpy/gates/__init__.py diff --git a/python/ffsim/tenpy/gates/abstract_gates.py b/python/ffsim/tenpy/gates/abstract_gates.py new file mode 100644 index 000000000..612f695d8 --- /dev/null +++ b/python/ffsim/tenpy/gates/abstract_gates.py @@ -0,0 +1,81 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + + +import numpy as np +import tenpy.linalg.np_conserved as npc +from tenpy.algorithms.tebd import TEBDEngine +from tenpy.linalg.charges import LegPipe +from tenpy.networks.site import SpinHalfFermionSite + +# ignore lowercase argument and variable checks to maintain TeNPy naming conventions +# ruff: noqa: N803, N806 + +# define sites +shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") +shfsc = LegPipe([shfs.leg, shfs.leg]) + + +def apply_gate1(eng: TEBDEngine, U1: np.ndarray, site: int) -> None: + r"""Apply a single-site gate to an MPS. + + Args: + eng: The TEBD Engine. + U1: The single-site quantum gate. + site: The gate will be applied to `site` on the MPS. + + Returns: + None + """ + + # apply single-site gate + U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) + psi = eng.get_resume_data()["psi"] + psi.apply_local_op(site, U1_npc) + + +def apply_gate2( + eng: TEBDEngine, + U2: np.ndarray, + sites: tuple[int, int], + *, + norm_tol: float = 1e-5, +) -> None: + r"""Apply a two-site gate to an MPS. + + Args: + eng: The TEBD Engine. + U2: The two-site quantum gate. + sites: The gate will be applied to adjacent sites `(site1, site2)` on the MPS. + norm_tol: The norm error above which we recanonicalize the MPS. + + Returns: + None + """ + + # check that sites are adjacent + if abs(sites[0] - sites[1]) != 1: + raise ValueError("sites must be adjacent") + + # check whether to transpose gate + if sites[0] > sites[1]: + U2 = U2.T + + # apply NN gate between (site1, site2) + U2_npc = npc.Array.from_ndarray( + U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] + ) + U2_npc_split = U2_npc.split_legs() + eng.update_bond(max(sites), U2_npc_split) + + # recanonicalize psi if below error threshold + psi = eng.get_resume_data()["psi"] + if np.linalg.norm(psi.norm_test()) > norm_tol: + psi.canonical_form_finite() diff --git a/python/ffsim/tenpy/circuits/gates.py b/python/ffsim/tenpy/gates/basic_gates.py similarity index 53% rename from python/ffsim/tenpy/circuits/gates.py rename to python/ffsim/tenpy/gates/basic_gates.py index 73fe44d7f..241bb10a6 100644 --- a/python/ffsim/tenpy/circuits/gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -9,28 +9,17 @@ # that they have been altered from the originals. import cmath -import itertools import math import numpy as np -import tenpy.linalg.np_conserved as npc -from tenpy.algorithms.tebd import TEBDEngine -from tenpy.linalg.charges import LegPipe -from tenpy.networks.mps import MPS -from tenpy.networks.site import SpinHalfFermionSite -from ffsim.linalg import givens_decomposition from ffsim.spin import Spin -# ignore lowercase argument and variable checks to maintain TeNPy naming conventions -# ruff: noqa: N803, N806 +# ignore lowercase variable checks to maintain TeNPy naming conventions +# ruff: noqa: N806 -# define sites -shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") -shfsc = LegPipe([shfs.leg, shfs.leg]) - -def sym_cons_basis(gate: np.ndarray) -> np.ndarray: +def _sym_cons_basic(gate: np.ndarray) -> np.ndarray: r"""Convert a gate to the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -135,7 +124,7 @@ def givens_rotation(theta: float, spin: Spin, *, phi: float = 0.0) -> np.ndarray raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - Ggate_sym = sym_cons_basis(Ggate) + Ggate_sym = _sym_cons_basic(Ggate) return Ggate_sym @@ -187,7 +176,7 @@ def num_interaction(theta: float, spin: Spin) -> np.ndarray: raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - Ngate_sym = sym_cons_basis(Ngate) + Ngate_sym = _sym_cons_basic(Ngate) return Ngate_sym @@ -212,7 +201,7 @@ def on_site_interaction(theta: float) -> np.ndarray: OSgate[3, 3] = cmath.exp(1j * theta) # convert to (N, Sz)-symmetry-conserved basis - OSgate_sym = sym_cons_basis(OSgate) + OSgate_sym = _sym_cons_basic(OSgate) return OSgate_sym @@ -265,187 +254,6 @@ def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - NNgate_sym = sym_cons_basis(NNgate) + NNgate_sym = _sym_cons_basic(NNgate) return NNgate_sym - - -def apply_gate1(psi: MPS, U1: np.ndarray, site: int) -> None: - r"""Apply a single-site gate to a - `TeNPy MPS `__ - wavefunction. - - Args: - psi: The `TeNPy MPS `__ - wavefunction. - U1: The single-site quantum gate. - site: The gate will be applied to `site` on the - `TeNPy MPS `__ - wavefunction. - - Returns: - None - """ - - # apply single-site gate - U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) - psi.apply_local_op(site, U1_npc) - - -def apply_gate2( - psi: MPS, - U2: np.ndarray, - sites: tuple[int, int], - *, - eng: TEBDEngine, - chi_list: list, - norm_tol: float = 1e-5, -) -> None: - r"""Apply a two-site gate to a `TeNPy MPS `__ - wavefunction. - - Args: - psi: The `TeNPy MPS `__ - wavefunction. - U2: The two-site quantum gate. - sites: The gate will be applied to adjacent sites `(site1, site2)` on the - `TeNPy MPS `__ - wavefunction. - eng: The - `TeNPy TEBDEngine `__. - chi_list: The list to which to append the MPS bond dimensions as the circuit is - evaluated. - norm_tol: The norm error above which we recanonicalize the wavefunction, as - defined in the - `TeNPy documentation `__. - - Returns: - None - """ - - # check that sites are adjacent - if abs(sites[0] - sites[1]) != 1: - raise ValueError("sites must be adjacent") - - # check whether to transpose gate - if sites[0] > sites[1]: - U2 = U2.T - - # apply NN gate between (site1, site2) - U2_npc = npc.Array.from_ndarray( - U2, [shfsc, shfsc.conj()], labels=["(p0.p1)", "(p0*.p1*)"] - ) - U2_npc_split = U2_npc.split_legs() - eng.update_bond(max(sites), U2_npc_split) - chi_list.append(psi.chi) - - # recanonicalize psi if below error threshold - if np.linalg.norm(psi.norm_test()) > norm_tol: - psi.canonical_form_finite() - - -def apply_orbital_rotation( - psi: MPS, - mat: np.ndarray, - *, - eng: TEBDEngine, - chi_list: list, - norm_tol: float = 1e-5, -) -> None: - r"""Apply an orbital rotation gate to a - `TeNPy MPS `__ - wavefunction. - - The orbital rotation gate is defined in - `apply_orbital_rotation `__. - - Args: - psi: The `TeNPy MPS `__ - wavefunction. - mat: The orbital rotation matrix of dimension `(norb, norb)`. - eng: The - `TeNPy TEBDEngine `__. - chi_list: The list to which to append the MPS bond dimensions as the circuit is - evaluated. - norm_tol: The norm error above which we recanonicalize the wavefunction, as - defined in the - `TeNPy documentation `__. - - Returns: - None - """ - - # Givens decomposition - givens_list, diag_mat = givens_decomposition(mat) - - # apply the Givens rotation gates - for gate in givens_list: - theta = math.acos(gate.c) - phi = cmath.phase(gate.s) - np.pi - apply_gate2( - psi, - givens_rotation(theta, Spin.ALPHA_AND_BETA, phi=phi), - (gate.i, gate.j), - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) - - # apply the number interaction gates - for i, z in enumerate(diag_mat): - theta = cmath.phase(z) - apply_gate1(psi, num_interaction(-theta, Spin.ALPHA_AND_BETA), i) - - -def apply_diag_coulomb_evolution( - psi: MPS, - mat: np.ndarray, - *, - eng: TEBDEngine, - chi_list: list, - norm_tol: float = 1e-5, -) -> None: - r"""Apply a diagonal Coulomb evolution gate to a - `TeNPy MPS `__ - wavefunction. - - The diagonal Coulomb evolution gate is defined in - `apply_diag_coulomb_evolution `__. - - Args: - psi: The `TeNPy MPS `__ - wavefunction. - mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. - eng: The - `TeNPy TEBDEngine `__. - chi_list: The list to which to append the MPS bond dimensions as the circuit is - evaluated. - norm_tol: The norm error above which we recanonicalize the wavefunction, as - defined in the - `TeNPy documentation `__. - - Returns: - None - """ - - # extract norb - _, norb, _ = mat.shape - - # unpack alpha-alpha and alpha-beta matrices - mat_aa, mat_ab = mat - - # apply alpha-alpha gates - for i, j in itertools.product(range(norb), repeat=2): - if j > i and mat_aa[i, j]: - apply_gate2( - psi, - num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), - (i, j), - eng=eng, - chi_list=chi_list, - norm_tol=norm_tol, - ) - - # apply alpha-beta gates - for i in range(norb): - apply_gate1(psi, on_site_interaction(-mat_ab[i, i]), i) diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py new file mode 100644 index 000000000..b0a2df360 --- /dev/null +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -0,0 +1,59 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import itertools + +import numpy as np +from tenpy.algorithms.tebd import TEBDEngine + +from ffsim.spin import Spin +from ffsim.tenpy.gates.abstract_gates import apply_gate1, apply_gate2 +from ffsim.tenpy.gates.basic_gates import num_num_interaction, on_site_interaction + + +def apply_diag_coulomb_evolution( + eng: TEBDEngine, + mat: np.ndarray, + *, + norm_tol: float = 1e-5, +) -> None: + r"""Apply a diagonal Coulomb evolution gate to an MPS. + + The diagonal Coulomb evolution gate is defined in + `apply_diag_coulomb_evolution `__. + + Args: + eng: The TEBD Engine. + mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. + norm_tol: The norm error above which we recanonicalize the MPS. + + Returns: + None + """ + + # extract norb + norb = eng.get_resume_data()["psi"].L + + # unpack alpha-alpha and alpha-beta matrices + mat_aa, mat_ab = mat + + # apply alpha-alpha gates + for i, j in itertools.product(range(norb), repeat=2): + if j > i and mat_aa[i, j]: + apply_gate2( + eng, + num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), + (i, j), + norm_tol=norm_tol, + ) + + # apply alpha-beta gates + for i in range(norb): + apply_gate1(eng, on_site_interaction(-mat_ab[i, i]), i) diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py new file mode 100644 index 000000000..e31151836 --- /dev/null +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -0,0 +1,60 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import cmath +import math + +import numpy as np +from tenpy.algorithms.tebd import TEBDEngine + +from ffsim.linalg import givens_decomposition +from ffsim.spin import Spin +from ffsim.tenpy.gates.abstract_gates import apply_gate1, apply_gate2 +from ffsim.tenpy.gates.basic_gates import givens_rotation, num_interaction + + +def apply_orbital_rotation( + eng: TEBDEngine, + mat: np.ndarray, + *, + norm_tol: float = 1e-5, +) -> None: + r"""Apply an orbital rotation gate to an MPS. + + The orbital rotation gate is defined in + `apply_orbital_rotation `__. + + Args: + eng: The TEBD Engine. + mat: The orbital rotation matrix of dimension `(norb, norb)`. + norm_tol: The norm error above which we recanonicalize the MPS. + + Returns: + None + """ + + # Givens decomposition + givens_list, diag_mat = givens_decomposition(mat) + + # apply the Givens rotation gates + for gate in givens_list: + theta = math.acos(gate.c) + phi = cmath.phase(gate.s) - np.pi + apply_gate2( + eng, + givens_rotation(theta, Spin.ALPHA_AND_BETA, phi=phi), + (gate.i, gate.j), + norm_tol=norm_tol, + ) + + # apply the number interaction gates + for i, z in enumerate(diag_mat): + theta = cmath.phase(z) + apply_gate1(eng, num_interaction(-theta, Spin.ALPHA_AND_BETA), i) diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py new file mode 100644 index 000000000..593eb1e82 --- /dev/null +++ b/python/ffsim/tenpy/gates/ucj.py @@ -0,0 +1,62 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from __future__ import annotations + +import numpy as np +from tenpy.algorithms.tebd import TEBDEngine + +from ffsim.tenpy.gates.diag_coulomb import apply_diag_coulomb_evolution +from ffsim.tenpy.gates.orbital_rotation import apply_orbital_rotation +from ffsim.variational.ucj_spin_balanced import UCJOpSpinBalanced + + +def apply_ucj_op_spin_balanced( + eng: TEBDEngine, + ucj_op: UCJOpSpinBalanced, + *, + norm_tol: float = 1e-5, +) -> None: + r"""Construct the LUCJ circuit as an MPS. + + Args: + eng: The TEBD engine. + ucj_op: The LUCJ operator. + norm_tol: The norm error above which we recanonicalize the MPS. + + Returns: + None + """ + + # extract norb + norb = eng.get_resume_data()["psi"].L + + # construct the LUCJ MPS + current_basis = np.eye(norb) + for orb_rot, diag_mats in zip(ucj_op.orbital_rotations, ucj_op.diag_coulomb_mats): + apply_orbital_rotation( + eng, + orb_rot.conjugate().T @ current_basis, + norm_tol=norm_tol, + ) + apply_diag_coulomb_evolution(eng, diag_mats, norm_tol=norm_tol) + current_basis = orb_rot + if ucj_op.final_orbital_rotation is None: + apply_orbital_rotation( + eng, + current_basis, + norm_tol=norm_tol, + ) + else: + apply_orbital_rotation( + eng, + ucj_op.final_orbital_rotation @ current_basis, + norm_tol=norm_tol, + ) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index d33b82216..325d28a67 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -14,14 +14,14 @@ from tenpy.networks.site import SpinHalfFermionSite -def product_state_as_mps(bitstring: tuple[str, str]) -> MPS: - r"""Return the product state as an MPS. +def bitstring_to_mps(bitstring: tuple[str, str]) -> MPS: + r"""Return the bitstring as an MPS. Args: bitstring: The bitstring in the form `(string_a, string_b)`. Returns: - The product state as an MPS. + The bitstring as an MPS. """ # unpack bitstrings @@ -54,6 +54,6 @@ def product_state_as_mps(bitstring: tuple[str, str]) -> MPS: # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") - psi_mps = MPS.from_product_state([shfs] * norb, product_state) + mps = MPS.from_product_state([shfs] * norb, product_state) - return psi_mps + return mps diff --git a/python/ffsim/testing/__init__.py b/python/ffsim/testing/__init__.py index e59630ad0..61d38b667 100644 --- a/python/ffsim/testing/__init__.py +++ b/python/ffsim/testing/__init__.py @@ -16,6 +16,7 @@ generate_norb_nelec_spin, generate_norb_nocc, generate_norb_spin, + interaction_pairs_spin_balanced, random_nelec, random_occupied_orbitals, ) @@ -26,6 +27,7 @@ "generate_norb_nelec_spin", "generate_norb_nocc", "generate_norb_spin", + "interaction_pairs_spin_balanced", "random_nelec", "random_occupied_orbitals", ] diff --git a/python/ffsim/testing/testing.py b/python/ffsim/testing/testing.py index 4be6f0af4..0ef3629e5 100644 --- a/python/ffsim/testing/testing.py +++ b/python/ffsim/testing/testing.py @@ -153,3 +153,21 @@ def assert_allclose_up_to_global_phase( err_msg=err_msg, verbose=verbose, ) + + +def interaction_pairs_spin_balanced( + connectivity: str, norb: int +) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: + """Returns alpha-alpha and alpha-beta diagonal Coulomb interaction pairs.""" + if connectivity == "square": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb)] + elif connectivity == "hex": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb) if p % 2 == 0] + elif connectivity == "heavy-hex": + pairs_aa = [(p, p + 1) for p in range(norb - 1)] + pairs_ab = [(p, p) for p in range(norb) if p % 4 == 0] + else: + raise ValueError(f"Invalid connectivity: {connectivity}") + return pairs_aa, pairs_ab diff --git a/tests/python/tenpy/gates/__init__.py b/tests/python/tenpy/gates/__init__.py new file mode 100644 index 000000000..5f2c9d9c1 --- /dev/null +++ b/tests/python/tenpy/gates/__init__.py @@ -0,0 +1,9 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py new file mode 100644 index 000000000..2a1a62d62 --- /dev/null +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -0,0 +1,82 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for TeNPy orbital rotation gate.""" + +from copy import deepcopy + +import numpy as np +import pytest +from tenpy.algorithms.tebd import TEBDEngine + +import ffsim +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.util import bitstring_to_mps + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_apply_orbital_rotation( + norb: int, + nelec: tuple[int, int], +): + """Test applying orbital rotation to MPS.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((strings_a[idx], strings_b[idx])) + original_mps = deepcopy(mps) + + # generate a random orbital rotation + mat = ffsim.random.random_unitary(norb, seed=rng) + + # apply random orbital rotation to state vector + vec = ffsim.apply_orbital_rotation(original_vec, mat, norb, nelec) + + # apply random orbital rotation to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_orbital_rotation(eng, mat) + + # test matrix element is preserved + original_matrix_element = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) + mpo_matrix_element = mps.overlap(original_mps) + np.testing.assert_allclose(original_matrix_element, mpo_matrix_element) diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py new file mode 100644 index 000000000..9cc13d0a6 --- /dev/null +++ b/tests/python/tenpy/gates/ucj_test.py @@ -0,0 +1,101 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for TeNPy unitary cluster Jastrow gate.""" + +import numpy as np +import pytest +from tenpy.algorithms.tebd import TEBDEngine + +import ffsim +from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.util import bitstring_to_mps +from ffsim.testing import interaction_pairs_spin_balanced + + +@pytest.mark.parametrize( + "norb, nelec, n_reps, connectivity", + [ + (4, (2, 2), 1, "square"), + (4, (1, 2), 1, "square"), + (4, (0, 2), 1, "square"), + (4, (0, 0), 1, "square"), + (4, (2, 2), 1, "hex"), + (4, (1, 2), 1, "hex"), + (4, (0, 2), 1, "hex"), + (4, (0, 0), 1, "hex"), + (4, (2, 2), 1, "heavy-hex"), + (4, (1, 2), 1, "heavy-hex"), + (4, (0, 2), 1, "heavy-hex"), + (4, (0, 0), 1, "heavy-hex"), + (4, (2, 2), 2, "square"), + (4, (1, 2), 2, "square"), + (4, (0, 2), 2, "square"), + (4, (0, 0), 2, "square"), + (4, (2, 2), 2, "hex"), + (4, (1, 2), 2, "hex"), + (4, (0, 2), 2, "hex"), + (4, (0, 0), 2, "hex"), + (4, (2, 2), 2, "heavy-hex"), + (4, (1, 2), 2, "heavy-hex"), + (4, (0, 2), 2, "heavy-hex"), + (4, (0, 0), 2, "heavy-hex"), + ], +) +def test_apply_ucj_op_spin_balanced( + norb: int, nelec: tuple[int, int], n_reps: int, connectivity: str +): + """Test LUCJ circuit MPS construction.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random LUCJ ansatz + lucj_op = ffsim.random.random_ucj_op_spin_balanced( + norb=norb, + n_reps=n_reps, + interaction_pairs=interaction_pairs_spin_balanced( + connectivity=connectivity, norb=norb + ), + with_final_orbital_rotation=True, + seed=rng, + ) + + # generate the corresponding LUCJ circuit statevector + hf_state = ffsim.hartree_fock_state(norb, nelec) + lucj_state = ffsim.apply_unitary(hf_state, lucj_op, norb, nelec) + + # generate the corresponding LUCJ circuit MPS + dim = ffsim.dim(norb, nelec) + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + wavefunction_mps = bitstring_to_mps((strings_a[0], strings_b[0])) + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(wavefunction_mps, None, options) + apply_ucj_op_spin_balanced(eng, lucj_op) + + # test expectation is preserved + original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real + mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(wavefunction_mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/hamiltonians/__init__.py b/tests/python/tenpy/hamiltonians/__init__.py new file mode 100644 index 000000000..5f2c9d9c1 --- /dev/null +++ b/tests/python/tenpy/hamiltonians/__init__.py @@ -0,0 +1,9 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/tests/python/tenpy/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py similarity index 94% rename from tests/python/tenpy/molecular_hamiltonian_test.py rename to tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index ea04c2c3f..1e77b2080 100644 --- a/tests/python/tenpy/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -15,7 +15,7 @@ import ffsim from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import product_state_as_mps +from ffsim.tenpy.util import bitstring_to_mps @pytest.mark.parametrize( @@ -55,7 +55,7 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - product_state_mps = product_state_as_mps((strings_a[idx], strings_b[idx])) + product_state_mps = bitstring_to_mps((strings_a[idx], strings_b[idx])) # test expectation is preserved original_expectation = np.vdot(product_state, hamiltonian @ product_state) diff --git a/tests/python/tenpy/lucj_circuit_test.py b/tests/python/tenpy/lucj_circuit_test.py deleted file mode 100644 index d334e4c0f..000000000 --- a/tests/python/tenpy/lucj_circuit_test.py +++ /dev/null @@ -1,172 +0,0 @@ -# (C) Copyright IBM 2024. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -"""Tests for LUCJ circuit TeNPy methods.""" - -from copy import deepcopy - -import numpy as np -import pytest -from tenpy.algorithms.tebd import TEBDEngine - -import ffsim -from ffsim.tenpy.circuits.lucj_circuit import apply_ucj_op_spin_balanced -from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import product_state_as_mps - - -def _interaction_pairs_spin_balanced_( - connectivity: str, norb: int -) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: - """Returns alpha-alpha and alpha-beta diagonal Coulomb interaction pairs.""" - if connectivity == "square": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb)] - elif connectivity == "hex": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb) if p % 2 == 0] - elif connectivity == "heavy-hex": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb) if p % 4 == 0] - else: - raise ValueError(f"Invalid connectivity: {connectivity}") - return pairs_aa, pairs_ab - - -@pytest.mark.parametrize( - "norb, nelec, n_reps, connectivity", - [ - (4, (2, 2), 1, "square"), - (4, (1, 2), 1, "square"), - (4, (0, 2), 1, "square"), - (4, (0, 0), 1, "square"), - (4, (2, 2), 1, "hex"), - (4, (1, 2), 1, "hex"), - (4, (0, 2), 1, "hex"), - (4, (0, 0), 1, "hex"), - (4, (2, 2), 1, "heavy-hex"), - (4, (1, 2), 1, "heavy-hex"), - (4, (0, 2), 1, "heavy-hex"), - (4, (0, 0), 1, "heavy-hex"), - (4, (2, 2), 2, "square"), - (4, (1, 2), 2, "square"), - (4, (0, 2), 2, "square"), - (4, (0, 0), 2, "square"), - (4, (2, 2), 2, "hex"), - (4, (1, 2), 2, "hex"), - (4, (0, 2), 2, "hex"), - (4, (0, 0), 2, "hex"), - (4, (2, 2), 2, "heavy-hex"), - (4, (1, 2), 2, "heavy-hex"), - (4, (0, 2), 2, "heavy-hex"), - (4, (0, 0), 2, "heavy-hex"), - ], -) -def test_apply_ucj_op_spin_balanced( - norb: int, nelec: tuple[int, int], n_reps: int, connectivity: str -): - """Test LUCJ circuit MPS construction.""" - rng = np.random.default_rng() - - # generate a random molecular Hamiltonian - mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) - hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) - - # convert molecular Hamiltonian to MPO - mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( - mol_hamiltonian - ) - mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO - - # generate a random LUCJ ansatz - lucj_op = ffsim.random.random_ucj_op_spin_balanced( - norb=norb, - n_reps=n_reps, - interaction_pairs=_interaction_pairs_spin_balanced_( - connectivity=connectivity, norb=norb - ), - with_final_orbital_rotation=True, - seed=rng, - ) - - # generate the corresponding LUCJ circuit - lucj_state = ffsim.hartree_fock_state(norb, nelec) - lucj_state = ffsim.apply_unitary(lucj_state, lucj_op, norb, nelec) - - # convert LUCJ ansatz to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - wavefunction_mps, _ = apply_ucj_op_spin_balanced(lucj_op, norb, nelec, options) - - # test expectation is preserved - original_expectation = np.vdot(lucj_state, hamiltonian @ lucj_state).real - mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(wavefunction_mps) - np.testing.assert_allclose(original_expectation, mpo_expectation) - - -@pytest.mark.parametrize( - "norb, nelec", - [ - (4, (2, 2)), - (4, (1, 2)), - (4, (0, 2)), - (4, (0, 0)), - ], -) -def test_apply_orbital_rotation( - norb: int, - nelec: tuple[int, int], -): - """Test applying orbital rotation to MPS.""" - rng = np.random.default_rng() - - # generate a random molecular Hamiltonian - mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) - hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) - - # convert molecular Hamiltonian to MPO - mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( - mol_hamiltonian - ) - mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO - - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = product_state_as_mps((strings_a[idx], strings_b[idx])) - original_mps = deepcopy(mps) - - # generate a random orbital rotation - mat = ffsim.random.random_unitary(norb, seed=rng) - - # apply random orbital rotation to state vector - vec = ffsim.apply_orbital_rotation(original_vec, mat, norb, nelec) - - # apply random orbital rotation to MPS - chi_list: list[int] = [] - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) - ffsim.tenpy.apply_orbital_rotation(mps, mat, eng=eng, chi_list=chi_list) - - # test matrix element is preserved - original_matrix_element = np.vdot(original_vec, hamiltonian @ vec) - mol_hamiltonian_mpo.apply_naively(mps) - mpo_matrix_element = mps.overlap(original_mps) - np.testing.assert_allclose(original_matrix_element, mpo_matrix_element) From cee45388ce91268fcb353eb102d9f6ab2cb72476 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 15 Nov 2024 17:22:03 +0100 Subject: [PATCH 58/88] improve docstrings --- python/ffsim/tenpy/gates/ucj.py | 4 ++-- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 2 +- tests/python/tenpy/gates/orbital_rotation_test.py | 4 ++-- tests/python/tenpy/gates/ucj_test.py | 4 ++-- tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index 593eb1e82..a394450a6 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -24,11 +24,11 @@ def apply_ucj_op_spin_balanced( *, norm_tol: float = 1e-5, ) -> None: - r"""Construct the LUCJ circuit as an MPS. + r"""Apply a spin-balanced unitary cluster Jastrow gate to an MPS. Args: eng: The TEBD engine. - ucj_op: The LUCJ operator. + ucj_op: The spin-balanced unitary cluster Jastrow operator. norm_tol: The norm error above which we recanonicalize the MPS. Returns: diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 0091adb87..91c183306 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -127,7 +127,7 @@ def from_molecular_hamiltonian( molecular_hamiltonian: The molecular Hamiltonian. Returns: - The molecular Hamiltonian as a `TeNPy MPOModel `__. + The molecular Hamiltonian as an MPO model. """ model_params = dict( diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 2a1a62d62..769d539ff 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -8,7 +8,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Tests for TeNPy orbital rotation gate.""" +"""Tests for the TeNPy orbital rotation gate.""" from copy import deepcopy @@ -34,7 +34,7 @@ def test_apply_orbital_rotation( norb: int, nelec: tuple[int, int], ): - """Test applying orbital rotation to MPS.""" + """Test applying an orbital rotation gate to an MPS.""" rng = np.random.default_rng() # generate a random molecular Hamiltonian diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py index 9cc13d0a6..21ab58223 100644 --- a/tests/python/tenpy/gates/ucj_test.py +++ b/tests/python/tenpy/gates/ucj_test.py @@ -8,7 +8,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Tests for TeNPy unitary cluster Jastrow gate.""" +"""Tests for the TeNPy unitary cluster Jastrow gate.""" import numpy as np import pytest @@ -53,7 +53,7 @@ def test_apply_ucj_op_spin_balanced( norb: int, nelec: tuple[int, int], n_reps: int, connectivity: str ): - """Test LUCJ circuit MPS construction.""" + """Test applying a spin-balanced unitary cluster Jastrow gate to an MPS.""" rng = np.random.default_rng() # generate a random molecular Hamiltonian diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 1e77b2080..8e5fc4f12 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -8,7 +8,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Tests for molecular Hamiltonian TeNPy methods.""" +"""Tests for the TeNPy molecular Hamiltonian.""" import numpy as np import pytest From c4f305ec6428ac0a2fd582f5e59212713e5b81e3 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 21 Nov 2024 16:42:29 +0100 Subject: [PATCH 59/88] add more gate tests --- python/ffsim/tenpy/__init__.py | 8 +- python/ffsim/tenpy/gates/abstract_gates.py | 4 +- python/ffsim/tenpy/gates/basic_gates.py | 8 +- python/ffsim/tenpy/gates/diag_coulomb.py | 9 +- python/ffsim/tenpy/gates/orbital_rotation.py | 9 +- .../hamiltonians/molecular_hamiltonian.py | 21 +- python/ffsim/tenpy/util.py | 13 +- tests/python/tenpy/gates/basic_gates_test.py | 251 ++++++++++++++++++ tests/python/tenpy/gates/diag_coulomb_test.py | 75 ++++++ .../tenpy/gates/orbital_rotation_test.py | 22 +- tests/python/tenpy/gates/ucj_test.py | 11 +- .../molecular_hamiltonian_test.py | 4 +- 12 files changed, 371 insertions(+), 64 deletions(-) create mode 100644 tests/python/tenpy/gates/basic_gates_test.py create mode 100644 tests/python/tenpy/gates/diag_coulomb_test.py diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index d72ec1ec4..ba7306498 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -11,8 +11,8 @@ """Code that uses TeNPy, e.g. for emulating quantum circuits.""" from ffsim.tenpy.gates.abstract_gates import ( - apply_gate1, - apply_gate2, + apply_single_site, + apply_two_site, ) from ffsim.tenpy.gates.basic_gates import ( givens_rotation, @@ -29,9 +29,9 @@ __all__ = [ "apply_ucj_op_spin_balanced", "apply_diag_coulomb_evolution", - "apply_gate1", - "apply_gate2", "apply_orbital_rotation", + "apply_single_site", + "apply_two_site", "bitstring_to_mps", "givens_rotation", "MolecularHamiltonianMPOModel", diff --git a/python/ffsim/tenpy/gates/abstract_gates.py b/python/ffsim/tenpy/gates/abstract_gates.py index 612f695d8..5eba1b5d7 100644 --- a/python/ffsim/tenpy/gates/abstract_gates.py +++ b/python/ffsim/tenpy/gates/abstract_gates.py @@ -23,7 +23,7 @@ shfsc = LegPipe([shfs.leg, shfs.leg]) -def apply_gate1(eng: TEBDEngine, U1: np.ndarray, site: int) -> None: +def apply_single_site(eng: TEBDEngine, U1: np.ndarray, site: int) -> None: r"""Apply a single-site gate to an MPS. Args: @@ -41,7 +41,7 @@ def apply_gate1(eng: TEBDEngine, U1: np.ndarray, site: int) -> None: psi.apply_local_op(site, U1_npc) -def apply_gate2( +def apply_two_site( eng: TEBDEngine, U2: np.ndarray, sites: tuple[int, int], diff --git a/python/ffsim/tenpy/gates/basic_gates.py b/python/ffsim/tenpy/gates/basic_gates.py index 241bb10a6..5992c940c 100644 --- a/python/ffsim/tenpy/gates/basic_gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -44,7 +44,9 @@ def _sym_cons_basic(gate: np.ndarray) -> np.ndarray: return gate[perm][:, perm] -def givens_rotation(theta: float, spin: Spin, *, phi: float = 0.0) -> np.ndarray: +def givens_rotation( + theta: float, spin: Spin = Spin.ALPHA_AND_BETA, *, phi: float = 0.0 +) -> np.ndarray: r"""The Givens rotation gate. The Givens rotation gate as defined in @@ -129,7 +131,7 @@ def givens_rotation(theta: float, spin: Spin, *, phi: float = 0.0) -> np.ndarray return Ggate_sym -def num_interaction(theta: float, spin: Spin) -> np.ndarray: +def num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarray: r"""The number interaction gate. The number interaction gate as defined in @@ -206,7 +208,7 @@ def on_site_interaction(theta: float) -> np.ndarray: return OSgate_sym -def num_num_interaction(theta: float, spin: Spin) -> np.ndarray: +def num_num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarray: r"""The number-number interaction gate. The number-number interaction gate as defined in diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py index b0a2df360..27dacc3f0 100644 --- a/python/ffsim/tenpy/gates/diag_coulomb.py +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -13,8 +13,7 @@ import numpy as np from tenpy.algorithms.tebd import TEBDEngine -from ffsim.spin import Spin -from ffsim.tenpy.gates.abstract_gates import apply_gate1, apply_gate2 +from ffsim.tenpy.gates.abstract_gates import apply_single_site, apply_two_site from ffsim.tenpy.gates.basic_gates import num_num_interaction, on_site_interaction @@ -47,13 +46,13 @@ def apply_diag_coulomb_evolution( # apply alpha-alpha gates for i, j in itertools.product(range(norb), repeat=2): if j > i and mat_aa[i, j]: - apply_gate2( + apply_two_site( eng, - num_num_interaction(-mat_aa[i, j], Spin.ALPHA_AND_BETA), + num_num_interaction(-mat_aa[i, j]), (i, j), norm_tol=norm_tol, ) # apply alpha-beta gates for i in range(norb): - apply_gate1(eng, on_site_interaction(-mat_ab[i, i]), i) + apply_single_site(eng, on_site_interaction(-mat_ab[i, i]), i) diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py index e31151836..7f4823527 100644 --- a/python/ffsim/tenpy/gates/orbital_rotation.py +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -15,8 +15,7 @@ from tenpy.algorithms.tebd import TEBDEngine from ffsim.linalg import givens_decomposition -from ffsim.spin import Spin -from ffsim.tenpy.gates.abstract_gates import apply_gate1, apply_gate2 +from ffsim.tenpy.gates.abstract_gates import apply_single_site, apply_two_site from ffsim.tenpy.gates.basic_gates import givens_rotation, num_interaction @@ -47,9 +46,9 @@ def apply_orbital_rotation( for gate in givens_list: theta = math.acos(gate.c) phi = cmath.phase(gate.s) - np.pi - apply_gate2( + apply_two_site( eng, - givens_rotation(theta, Spin.ALPHA_AND_BETA, phi=phi), + givens_rotation(theta, phi=phi), (gate.i, gate.j), norm_tol=norm_tol, ) @@ -57,4 +56,4 @@ def apply_orbital_rotation( # apply the number interaction gates for i, z in enumerate(diag_mat): theta = cmath.phase(z) - apply_gate1(eng, num_interaction(-theta, Spin.ALPHA_AND_BETA), i) + apply_single_site(eng, num_interaction(-theta), i) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 91c183306..63a962255 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -27,14 +27,14 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" def init_sites(self, params): - cons_N = params.get("cons_N", "N") - cons_Sz = params.get("cons_Sz", "Sz") + cons_N = params.get("cons_N", "N", expect_type=str) + cons_Sz = params.get("cons_Sz", "Sz", expect_type=str) site = SpinHalfFermionSite(cons_N=cons_N, cons_Sz=cons_Sz) return site def init_lattice(self, params): - L = params.get("L", 1) - norb = params.get("norb", 4) + L = params.get("L", 1, expect_type=int) + norb = params.get("norb", None, expect_type=int) site = self.init_sites(params) basis = np.array(([norb, 0.0], [0, 1])) pos = np.array([[i, 0] for i in range(norb)]) @@ -51,12 +51,14 @@ def init_lattice(self, params): def init_terms(self, params): dx0 = np.array([0, 0]) - norb = params.get("norb", 4) - one_body_tensor = params.get("one_body_tensor", np.zeros((norb, norb))) + norb = params.get("norb", None, expect_type=int) + one_body_tensor = params.get( + "one_body_tensor", np.zeros((norb, norb)), expect_type="array" + ) two_body_tensor = params.get( - "two_body_tensor", np.zeros((norb, norb, norb, norb)) + "two_body_tensor", np.zeros((norb, norb, norb, norb)), expect_type="array" ) - constant = params.get("constant", 0) + constant = params.get("constant", 0, expect_type="real") for p, q in itertools.product(range(norb), repeat=2): h1 = one_body_tensor[q, p] @@ -131,9 +133,6 @@ def from_molecular_hamiltonian( """ model_params = dict( - cons_N="N", - cons_Sz="Sz", - L=1, norb=molecular_hamiltonian.norb, one_body_tensor=molecular_hamiltonian.one_body_tensor, two_body_tensor=molecular_hamiltonian.two_body_tensor, diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 325d28a67..75cd181e1 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -14,22 +14,21 @@ from tenpy.networks.site import SpinHalfFermionSite -def bitstring_to_mps(bitstring: tuple[str, str]) -> MPS: +def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: r"""Return the bitstring as an MPS. Args: - bitstring: The bitstring in the form `(string_a, string_b)`. + bitstring: The bitstring in the form `(int_a, int_b)`. + norb: The number of spatial orbitals. Returns: The bitstring as an MPS. """ # unpack bitstrings - string_a, string_b = bitstring - - # extract norb - assert len(string_a) == len(string_b) - norb = len(string_a) + int_a, int_b = bitstring + string_a = f"{int_a:0{norb}b}" + string_b = f"{int_b:0{norb}b}" # merge bitstrings up_sector = string_a.replace("1", "u") diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py new file mode 100644 index 000000000..d26d8387e --- /dev/null +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -0,0 +1,251 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the TeNPy basic gates.""" + +from copy import deepcopy + +import numpy as np +import pytest +from tenpy.algorithms.tebd import TEBDEngine + +import ffsim +from ffsim.spin import Spin +from ffsim.tenpy.gates.basic_gates import ( + givens_rotation, + num_interaction, + num_num_interaction, + on_site_interaction, +) +from ffsim.tenpy.util import bitstring_to_mps + + +@pytest.mark.parametrize( + "norb, nelec, spin", + [ + (4, (2, 2), Spin.ALPHA), + (4, (1, 2), Spin.ALPHA), + (4, (0, 2), Spin.ALPHA), + (4, (0, 0), Spin.ALPHA), + (4, (2, 2), Spin.BETA), + (4, (1, 2), Spin.BETA), + (4, (0, 2), Spin.BETA), + (4, (0, 0), Spin.BETA), + (4, (2, 2), Spin.ALPHA_AND_BETA), + (4, (1, 2), Spin.ALPHA_AND_BETA), + (4, (0, 2), Spin.ALPHA_AND_BETA), + (4, (0, 0), Spin.ALPHA_AND_BETA), + ], +) +def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): + """Test applying a Givens rotation gate to an MPS.""" + rng = np.random.default_rng() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + original_mps = deepcopy(mps) + + # generate random Givens rotation parameters + theta = 2 * np.pi * rng.random() + phi = 2 * np.pi * rng.random() + p = rng.integers(0, norb - 1) + + # apply random Givens rotation to state vector + vec = ffsim.apply_givens_rotation( + original_vec, theta, (p, p + 1), norb, nelec, spin, phi=phi + ) + + # apply random orbital rotation to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p, p + 1)) + + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = original_mps.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) + + +@pytest.mark.parametrize( + "norb, nelec, spin", + [ + (4, (2, 2), Spin.ALPHA), + (4, (1, 2), Spin.ALPHA), + (4, (0, 2), Spin.ALPHA), + (4, (0, 0), Spin.ALPHA), + (4, (2, 2), Spin.BETA), + (4, (1, 2), Spin.BETA), + (4, (0, 2), Spin.BETA), + (4, (0, 0), Spin.BETA), + (4, (2, 2), Spin.ALPHA_AND_BETA), + (4, (1, 2), Spin.ALPHA_AND_BETA), + (4, (0, 2), Spin.ALPHA_AND_BETA), + (4, (0, 0), Spin.ALPHA_AND_BETA), + ], +) +def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): + """Test applying a number interaction gate to an MPS.""" + rng = np.random.default_rng() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + original_mps = deepcopy(mps) + + # generate random number interaction parameters + theta = 2 * np.pi * rng.random() + p = rng.integers(0, norb) + + # apply random number interaction to state vector + vec = ffsim.apply_num_interaction(original_vec, theta, p, norb, nelec, spin) + + # apply random number interaction to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_single_site(eng, num_interaction(theta, spin), p) + + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = original_mps.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_on_site_interaction( + norb: int, + nelec: tuple[int, int], +): + """Test applying an on-site interaction gate to an MPS.""" + rng = np.random.default_rng() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + original_mps = deepcopy(mps) + + # generate random on-site interaction parameters + theta = 2 * np.pi * rng.random() + p = rng.integers(0, norb) + + # apply random on-site interaction to state vector + vec = ffsim.apply_on_site_interaction(original_vec, theta, p, norb, nelec) + + # apply random on-site interaction to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_single_site(eng, on_site_interaction(theta), p) + + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = original_mps.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) + + +@pytest.mark.parametrize( + "norb, nelec, spin", + [ + (4, (2, 2), Spin.ALPHA), + (4, (1, 2), Spin.ALPHA), + (4, (0, 2), Spin.ALPHA), + (4, (0, 0), Spin.ALPHA), + (4, (2, 2), Spin.BETA), + (4, (1, 2), Spin.BETA), + (4, (0, 2), Spin.BETA), + (4, (0, 0), Spin.BETA), + (4, (2, 2), Spin.ALPHA_AND_BETA), + (4, (1, 2), Spin.ALPHA_AND_BETA), + (4, (0, 2), Spin.ALPHA_AND_BETA), + (4, (0, 0), Spin.ALPHA_AND_BETA), + ], +) +def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): + """Test applying a number-number interaction gate to an MPS.""" + rng = np.random.default_rng() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + original_mps = deepcopy(mps) + + # generate random number-number interaction parameters + theta = 2 * np.pi * rng.random() + p = rng.integers(0, norb - 1) + + # apply random number-number interaction to state vector + vec = ffsim.apply_num_num_interaction( + original_vec, theta, (p, p + 1), norb, nelec, spin + ) + + # apply random number-number interaction to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_two_site(eng, num_num_interaction(theta, spin), (p, p + 1)) + + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = original_mps.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py new file mode 100644 index 000000000..00e6597ed --- /dev/null +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -0,0 +1,75 @@ +# (C) Copyright IBM 2024. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the TeNPy diagonal Coulomb evolution gate.""" + +from copy import deepcopy + +import numpy as np +import pytest +from tenpy.algorithms.tebd import TEBDEngine + +import ffsim +from ffsim.tenpy.util import bitstring_to_mps + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (4, (2, 2)), + (4, (1, 2)), + (4, (0, 2)), + (4, (0, 0)), + ], +) +def test_apply_diag_coulomb_evolution( + norb: int, + nelec: tuple[int, int], +): + """Test applying a diagonal Coulomb evolution gate to an MPS.""" + rng = np.random.default_rng() + + # generate a random product state + dim = ffsim.dim(norb, nelec) + idx = rng.integers(0, high=dim) + original_vec = np.zeros(dim, dtype=complex) + original_vec[idx] = 1 + + # convert random product state to MPS + strings_a, strings_b = ffsim.addresses_to_strings( + range(dim), + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + original_mps = deepcopy(mps) + + # generate random diagonal Coulomb evolution parameters + mat_aa = np.diag(rng.standard_normal(norb - 1), k=-1) + mat_aa += mat_aa.T + mat_ab = np.diag(rng.standard_normal(norb)) + diag_coulomb_mats = np.array([mat_aa, mat_ab, mat_aa]) + + # apply random diagonal Coulomb evolution to state vector + vec = ffsim.apply_diag_coulomb_evolution( + original_vec, diag_coulomb_mats, 1, norb, nelec + ) + + # apply random diagonal Coulomb evolution to MPS + options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} + eng = TEBDEngine(mps, None, options) + ffsim.tenpy.apply_diag_coulomb_evolution(eng, diag_coulomb_mats[:2]) + + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = original_mps.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 769d539ff..2c472dee4 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -17,7 +17,6 @@ from tenpy.algorithms.tebd import TEBDEngine import ffsim -from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps @@ -37,16 +36,6 @@ def test_apply_orbital_rotation( """Test applying an orbital rotation gate to an MPS.""" rng = np.random.default_rng() - # generate a random molecular Hamiltonian - mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) - hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) - - # convert molecular Hamiltonian to MPO - mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( - mol_hamiltonian - ) - mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO - # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) @@ -61,7 +50,7 @@ def test_apply_orbital_rotation( bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((strings_a[idx], strings_b[idx])) + mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) original_mps = deepcopy(mps) # generate a random orbital rotation @@ -75,8 +64,7 @@ def test_apply_orbital_rotation( eng = TEBDEngine(mps, None, options) ffsim.tenpy.apply_orbital_rotation(eng, mat) - # test matrix element is preserved - original_matrix_element = np.vdot(original_vec, hamiltonian @ vec) - mol_hamiltonian_mpo.apply_naively(mps) - mpo_matrix_element = mps.overlap(original_mps) - np.testing.assert_allclose(original_matrix_element, mpo_matrix_element) + # test expectation is preserved + original_expectation = np.vdot(original_vec, vec) + mpo_expectation = mps.overlap(original_mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py index 21ab58223..b09f83de1 100644 --- a/tests/python/tenpy/gates/ucj_test.py +++ b/tests/python/tenpy/gates/ucj_test.py @@ -82,15 +82,8 @@ def test_apply_ucj_op_spin_balanced( lucj_state = ffsim.apply_unitary(hf_state, lucj_op, norb, nelec) # generate the corresponding LUCJ circuit MPS - dim = ffsim.dim(norb, nelec) - strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - wavefunction_mps = bitstring_to_mps((strings_a[0], strings_b[0])) + n_alpha, n_beta = nelec + wavefunction_mps = bitstring_to_mps(((1 << n_alpha) - 1, (1 << n_beta) - 1), norb) options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} eng = TEBDEngine(wavefunction_mps, None, options) apply_ucj_op_spin_balanced(eng, lucj_op) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 8e5fc4f12..68d88025c 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -55,7 +55,9 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - product_state_mps = bitstring_to_mps((strings_a[idx], strings_b[idx])) + product_state_mps = bitstring_to_mps( + (int(strings_a[idx], 2), int(strings_b[idx], 2)), norb + ) # test expectation is preserved original_expectation = np.vdot(product_state, hamiltonian @ product_state) From 03110200b77fb5c82318566f79c378b47bc3d42d Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 21 Nov 2024 17:23:32 +0100 Subject: [PATCH 60/88] fix notebook --- docs/how-to-guides/lucj_mps.ipynb | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index c204e4da3..7e14eb7d0 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -42,9 +42,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmpzfgzc02x\n", - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "Parsing /tmp/tmp8abr64eg\n", + "converged SCF energy = -77.8266321248745\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -53,7 +53,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_hcore get_ovlp of \n", + "Overwritten attributes get_ovlp get_hcore of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -94,6 +94,7 @@ "mol_data = ffsim.MolecularData.from_scf(scf, active_space=active_space)\n", "norb = mol_data.norb\n", "nelec = mol_data.nelec\n", + "n_alpha, n_beta = nelec\n", "mol_hamiltonian = mol_data.hamiltonian\n", "\n", "# Compute FCI energy\n", @@ -128,7 +129,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374035 E_corr = -0.0475832388658516\n" + "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585947\n" ] }, { @@ -268,7 +269,7 @@ " bitstring_type=ffsim.BitstringType.STRING,\n", " concatenate=False,\n", ")\n", - "psi_mps = bitstring_to_mps((strings_a[0], strings_b[0]))\n", + "psi_mps = bitstring_to_mps(((1 << n_alpha) - 1, (1 << n_beta) - 1), norb)\n", "\n", "# Construct the TEBD engine\n", "options = {\"trunc_params\": {\"chi_max\": 15, \"svd_min\": 1e-6}}\n", @@ -314,9 +315,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77102552350492\n", - "LUCJ energy = -77.84651018653346\n", - "FCI energy = -77.87421656438624\n" + "LUCJ (MPS) energy = -77.77309168986469\n", + "LUCJ energy = -77.84651018653345\n", + "FCI energy = -77.87421656438629\n" ] } ], @@ -358,7 +359,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -387,7 +388,7 @@ " bitstring_type=ffsim.BitstringType.STRING,\n", " concatenate=False,\n", ")\n", - "initial_mps = bitstring_to_mps((strings_a[0], strings_b[0]))\n", + "initial_mps = bitstring_to_mps(((1 << n_alpha) - 1, (1 << n_beta) - 1), norb)\n", "\n", "# Loop over cutoff and bond dimension\n", "for i, svd_min in enumerate(svd_min_list):\n", From 0f848457f1262bd15090c75f683ef3efe9b40583 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 21 Nov 2024 17:41:03 +0100 Subject: [PATCH 61/88] fix typo --- python/ffsim/tenpy/gates/basic_gates.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/python/ffsim/tenpy/gates/basic_gates.py b/python/ffsim/tenpy/gates/basic_gates.py index 5992c940c..ca52a5e70 100644 --- a/python/ffsim/tenpy/gates/basic_gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -19,7 +19,7 @@ # ruff: noqa: N806 -def _sym_cons_basic(gate: np.ndarray) -> np.ndarray: +def _sym_cons_basis(gate: np.ndarray) -> np.ndarray: r"""Convert a gate to the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -126,7 +126,7 @@ def givens_rotation( raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - Ggate_sym = _sym_cons_basic(Ggate) + Ggate_sym = _sym_cons_basis(Ggate) return Ggate_sym @@ -178,7 +178,7 @@ def num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarra raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - Ngate_sym = _sym_cons_basic(Ngate) + Ngate_sym = _sym_cons_basis(Ngate) return Ngate_sym @@ -203,7 +203,7 @@ def on_site_interaction(theta: float) -> np.ndarray: OSgate[3, 3] = cmath.exp(1j * theta) # convert to (N, Sz)-symmetry-conserved basis - OSgate_sym = _sym_cons_basic(OSgate) + OSgate_sym = _sym_cons_basis(OSgate) return OSgate_sym @@ -256,6 +256,6 @@ def num_num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.nd raise ValueError("undefined spin") # convert to (N, Sz)-symmetry-conserved basis - NNgate_sym = _sym_cons_basic(NNgate) + NNgate_sym = _sym_cons_basis(NNgate) return NNgate_sym From df7bab5ce4f8556886903146dfa4a8c48764bd4f Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 22 Nov 2024 11:33:18 +0100 Subject: [PATCH 62/88] address review comments --- docs/how-to-guides/lucj_mps.ipynb | 40 ++++------- python/ffsim/tenpy/gates/abstract_gates.py | 13 ++-- python/ffsim/tenpy/gates/basic_gates.py | 70 +++++++++---------- python/ffsim/tenpy/gates/diag_coulomb.py | 16 +++-- python/ffsim/tenpy/gates/orbital_rotation.py | 13 ++-- python/ffsim/tenpy/gates/ucj.py | 11 ++- .../hamiltonians/molecular_hamiltonian.py | 38 +++++----- python/ffsim/tenpy/util.py | 2 + tests/python/tenpy/gates/basic_gates_test.py | 28 ++++---- tests/python/tenpy/gates/diag_coulomb_test.py | 7 +- .../tenpy/gates/orbital_rotation_test.py | 7 +- .../molecular_hamiltonian_test.py | 7 +- 12 files changed, 123 insertions(+), 129 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 7e14eb7d0..d0272a63a 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -42,9 +42,9 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmp8abr64eg\n", + "Parsing /tmp/tmpnxxef5hr\n", "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -53,7 +53,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_ovlp get_hcore of \n", + "Overwritten attributes get_hcore get_ovlp of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", @@ -129,7 +129,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585947\n" + "E(CCSD) = -77.87421536374033 E_corr = -0.0475832388658431\n" ] }, { @@ -155,7 +155,7 @@ "pairs_ab = [(p, p) for p in range(norb)]\n", "interaction_pairs = (pairs_aa, pairs_ab)\n", "\n", - "lucj_operator = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n", + "lucj_op = ffsim.UCJOpSpinBalanced.from_t_amplitudes(\n", " ccsd.t2, n_reps=n_reps, interaction_pairs=interaction_pairs\n", ")" ] @@ -261,14 +261,6 @@ "from ffsim.tenpy.util import bitstring_to_mps\n", "\n", "# Construct Hartree-Fock state\n", - "dim = ffsim.dim(norb, nelec)\n", - "strings_a, strings_b = ffsim.addresses_to_strings(\n", - " range(dim),\n", - " norb=norb,\n", - " nelec=nelec,\n", - " bitstring_type=ffsim.BitstringType.STRING,\n", - " concatenate=False,\n", - ")\n", "psi_mps = bitstring_to_mps(((1 << n_alpha) - 1, (1 << n_beta) - 1), norb)\n", "\n", "# Construct the TEBD engine\n", @@ -276,7 +268,7 @@ "eng = TEBDEngine(psi_mps, None, options)\n", "\n", "# Apply the LUCJ operator\n", - "apply_ucj_op_spin_balanced(eng, lucj_operator)\n", + "apply_ucj_op_spin_balanced(eng, lucj_op)\n", "\n", "# Print the wavefunction\n", "psi_mps = eng.get_resume_data()[\"psi\"]\n", @@ -315,9 +307,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77309168986469\n", - "LUCJ energy = -77.84651018653345\n", - "FCI energy = -77.87421656438629\n" + "LUCJ (MPS) energy = -77.78472901487439\n", + "LUCJ energy = -77.84651018653346\n", + "FCI energy = -77.8742165643863\n" ] } ], @@ -328,7 +320,7 @@ "\n", "# Compute the LUCJ energy\n", "hf_state = ffsim.hartree_fock_state(norb, nelec)\n", - "lucj_state = ffsim.apply_unitary(hf_state, lucj_operator, norb, nelec)\n", + "lucj_state = ffsim.apply_unitary(hf_state, lucj_op, norb, nelec)\n", "hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec)\n", "lucj_energy = np.vdot(lucj_state, hamiltonian @ lucj_state).real\n", "print(\"LUCJ energy = \", lucj_energy)\n", @@ -359,7 +351,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAF1CAYAAACK41mYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACVz0lEQVR4nOzdeXxU9f398dedyZ4hCSEbIewESNgSCESwIGoqRkRca10Bl6oFly9qC20BtS38Wpe60WIVRVtU1BakqLiAigsQSIgSCIsYwp4QAglJyDrz+yNmJGYhgSR3JjnPx+OWzJ3P3HumE2fynvu572s4HA4HIiIiIiIi0mYsZgcQERERERHpaFSIiYiIiIiItDEVYiIiIiIiIm1MhZiIiIiIiEgbUyEmIiIiIiLSxlSIiYiIiIiItDEVYiIiIiIiIm1MhZiIiIiIiEgbUyEmIiIiIiLSxlSIiYiIiIiItDEPswM0xWeffcaFF15Y730pKSmMHDkSAIfDwZNPPsk///lPsrOzCQkJ4de//jW///3vG9z2rl27ePjhh/nqq68oLy9n6NCh/PGPf2xwf/Wx2+0cOnSITp06YRhG856ciEgH53A4OHnyJJGRkVgs+n7QFehzTUTk7DX1c80tCrExY8Zw+PDhWuvmzJnDmjVrSEhIcK67//77+eijj3jiiScYMmQI+fn55OfnN7rtyy+/nOjoaNauXYuvry9PP/00l19+OXv27CEiIqJJ+Q4dOkT37t2b/8RERMRp//79REVFmR1D0OeaiEhLONPnmuFwOBxtmKdFVFRU0K1bN+69917mzJkDQGZmJkOHDiUjI4MBAwY0aTt5eXmEhoaybt06xo4dC8DJkycJCAjg448/JikpqUnbKSgoICgoiP379xMQEHB2T0pEpIMqLCyke/funDhxgsDAQLPjCPpcExE5F039XHOLI2I/tXLlSo4dO8a0adOc6/73v//Rp08fVq1axaWXXorD4SApKYm//vWvBAcH17udLl26MGDAAF577TWGDx+Ot7c3L7zwAmFhYYwYMaLB/ZeVlVFWVua8ffLkSQACAgL0gSUicpY0Bc511LwW+lwTETl7Z/pcc8vJ+IsXL2bChAm1DvV9//33ZGdn8/bbb/Paa6+xZMkSUlNTufbaaxvcjmEYfPLJJ2zZsoVOnTrh4+PDU089xerVq+ncuXODj1uwYAGBgYHORdM3RERERESkOUwtxGbNmoVhGI0uO3bsqPWYAwcO8OGHH3L77bfXWm+32ykrK+O1115j7NixjB8/nsWLF/Ppp5+yc+fOevfvcDiYPn06YWFhfPHFF6SkpHDllVcyadKkOueknW727NkUFBQ4l/3795/7/xkiIiIiItJhmDo18cEHH2Tq1KmNjunTp0+t26+88gpdunThiiuuqLW+a9eueHh40L9/f+e6mJgYAPbt21fveWNr165l1apVHD9+3Dn14u9//zsff/wxr776KrNmzao3k7e3N97e3md8fiIiIiIiIvUxtRALDQ0lNDS0yeMdDgevvPIKt956K56enrXuO//886msrGTPnj307dsXqG5ND9CzZ896t1dSUgJQp62kxWLBbrc3OZeINJ3D4aCyspKqqiqzo0gbsVqteHh46BwwERGR07hVs461a9eSlZXFHXfcUee+pKQkhg8fzm233cbTTz+N3W5n+vTp/PznP3ceJUtJSeHWW29lzZo1dOvWjdGjR9O5c2emTJnC3Llz8fX15cUXXyQrK4uJEye29dMTaffKy8s5fPiw80sQ6Tj8/Pzo2rUrXl5eZkcRERFxCW5ViC1evJgxY8YwcODAOvdZLBb+97//ce+99zJu3Dj8/f1JTk7mySefdI4pKSlh586dVFRUABASEsLq1av5/e9/z0UXXURFRQWDBg3i3XffZdiwYW32vEQ6ArvdTlZWFlarlcjISLy8vHSEpANwOByUl5dz9OhRsrKyiI6O1kWb28iqVat48MEHsdvt/Pa3v633S0wRETGPW15HzNUUFhYSGBhIQUGB2vyKNKC0tJSsrCx69uyJn5+f2XGkjZWUlJCdnU3v3r3x8fGpdZ/eQ1teZWUlsbGxfPrppwQGBjJixAi+/vprunTp0qTH6zURETl7TX0P1deSItKmdDSkY9Lr3rZSUlIYNGgQ3bp1w2azkZyczEcffWR2LBEROY0+GU2Wc2APGV/9j5wDe8yOIiIiLmLdunVMmjSJyMhIDMNgxYoVdcYsXLiQXr164ePjQ2JiIikpKc77Dh06RLdu3Zy3u3XrxsGDB9siuj7XRESaSIWYiVLeeYrQF0cw+OObCXlxBCn/edrsSCIi4gKKi4sZNmwYCxcurPf+ZcuWMXPmTObNm0daWhrDhg1jwoQJ5ObmtnHS2lL+83Ttz7V3/mZqHhERV+ZWzTrak5wDexix9TEsRvUpelbDwfBvHyUncRLhUX1NTiciImZKTk4mOTm5wfufeuop7rzzTqZNmwbAokWLeO+993j55ZeZNWsWkZGRtY6AHTx4kFGjRjW4vbKyMsrKypy3CwsLm50558AeRnz7SK3PtZFbH2FX5lKOB8XiCBmIrccQIqOHExzWrfGNiYh0ACrETHI0ezvhRu0+KR6GnbzsHSrERESkQeXl5aSmpjJ79mznOovFQlJSEuvXrwdg1KhRZGRkcPDgQQIDA/nggw+YM2dOg9tcsGABjz766Dnlqu9zzTCgf9VuOLYbjr0LO4GPIZ8ADnv1pigwGsJiCOwxlK79hxPYOeScMoiIuBMVYiYJ7RlLlcPAetqHVqXDQkjPuq35RURczYkTJ0hKSqKyspLKykruv/9+7rzzTrNjdQh5eXlUVVURHh5ea314eDg7duwAwMPDgyeffJILL7wQu93Ob37zm0Y7Js6ePZuZM2c6bxcWFtK9e/dm5arvc63KYbAp5jc4Tubgc3wXYaf20NWeS7BRSHD5N3D0GzgKbAM+gFyCOeLTh5LAaCwRsQT1HEq36Dj8OwU1K4uIiDtQIWaS8Ki+pAx9hBHfPoLVcOBwQNqQuYzS0TARcQOdOnVi3bp1+Pn5UVxczODBg7n66qub3B5dWt8VV1zBFVdc0aSx3t7eeHt7n9P+aj7Xhn/7KB6GnUqHhbSh8zjvmgdqjSspKuDg7m84kf0tVUe243diF2GlWUSQRxj5hJXmQ+lmyAG+qX7MISOcXJ/enOrcH8+IWDr3Gka36GH4+PqfU2YRETOpEDPRqGse4MCwJML+NQ4vo4rwQePMjiQiDZg1axZ/+9vfuOaaa3j99dfNjmM6q9XqvB5cWVkZDocDXZaybYSEhGC1WsnJyam1Picnh4iICJNSVRt1zQPkJE4iL3sHIT0H1vvlop8tkOj4cRBf+zOv8MQxDu3eQmH2t9hztmMr3E1E2V5COEGkI4fIUzlwagMcAtKqj7btt3TlqF9fyjv3xzNyECG944jsOxhPL29yDuzhaPZ2QnvGasq/iLgkFWImi+o3mK0+QxlStoXD6R/SM2aE2ZFEpB6zZ88mKiqKe++9l8cee4x+/fqZHalB69at4/HHHyc1NZXDhw+zfPlyrrzyyjrjFi5cyOOPP86RI0cYNmwYzz33XKMNHX7qxIkTXHDBBezevZvHH3+ckBCd39MWvLy8GDFiBGvWrHG+rna7nTVr1jBjxgxzw1F9ZOxsCp+AoC4EjEyCkUm11h8/ephDu7dQtP9byM2kU+F3dKvIItAoprvjEN2LD0HxF3AASIFyh5UcI5AwRz7hBtgdkNppPJXdx2B4+WLx8sXq6YuHtx9Wr+p/PX388PLxw8vHHy8ff7x9fPH28cNogevfuUpBqBwirkeFmAsoijwfsrbgvf8Ls6OISAMCAwO5/fbbuf/++9m6datLF2I1rc9vu+02rr766nrH1LQ/X7RoEYmJiTz99NNMmDCBnTt3EhYWBkBcXByVlZV1HvvRRx8RGRlJUFAQ33zzDTk5OVx99dVce+21dc5bkrNTVFTEd99957ydlZVFeno6wcHB9OjRg5kzZzJlyhQSEhIYNWoUTz/9NMXFxc4uiu1J59CudA7tClzmXOew28k7sp/D36VRfCADy9FMAk/uIapiL/5GKeHkg1E91mLAiKLPIPOzZu+71OFJmeFFGd5UGJ5UGN5UWLypMLyptHpTZfHGbvXGbvXBbvXG4eGLw8MbPHwwPH2x5m5lRMEawg0HdofBhpCr8B00AYvVC8PDE6uHF1ZPbyxWT6yeXlg9PLF6eGP19MTD0wsPDy+snl54enrh4emF1epxVsVhyn+eZsS3jxBuOKhyGKQMfYRRP5ky2hZcJYeIqzAcmktyzgoLCwkMDKSgoICAgIBmP373lnVEvzuJkw5ffP+wDw9Pr1ZIKWKu0tJSsrKy6N27Nz4+Pue0rcMFp8jKK6Z3iD9dA31bKOGZnTx5ksjISH7zm9802oHOlRiGUe8RscTEREaOHMnzzz8PVB9R6d69O/feey+zZs1q9n5+/etfc9FFF3HttdfWe39jr/+5voe2R5999hkXXnhhnfVTpkxhyZIlADz//PPOI5pxcXE8++yzJCYmtsj+3fU1cdjtpL7/EgmbH65z33bPwVR4+OFRVYaHvQwPRxle9jI8HRV4UYa3oxxvyvEw7CYkb7pyh5VKPKg0rFThQSU//GtYqTI8sONBVc3Phgc4qhhYsQPD+HEbDgd865tAldUXZ8VqOP8Hh3OdUXvd6RupWX/aGE57nHMbP9y2VJQw4uSntTZR5TDIvGQp0SMuxNvH79z/zxFxEU19D9URMRfQZ8gYCt/1J8AoZuc3XzIg4SKzI4m0OofDwamKqmY/7j+pB5i3cht2R/U33Y9eMYhrRkQ1axu+nlaMWn9QNM0f/vAHioqKyMjIaPZjz8b8+fOZP39+o2O2b99Ojx49mrXdprQ/P5OcnBz8/Pzo1KkTBQUFrFu3jnvuuadZOaRh48ePP+M5dzNmzHCJqYiuxLBY6B53MVWb6nYl7jLltSZNhasoL6P0VDHlpSWUlxZTXnqKitJiKstKqCw/RVV5CVVlp6gqP4W9/BSOylIcFaVQcQoqT2GpLMWoKsO3+ABDyrbU2f4+I5JKwwsrVVgdldXLDyWVB1V4OH74lyrnNdlO52VU4UU9752OH5Z6/4/5yU0DhpVuPuP/Fy3uJzmshoPBH9+I/SODw0YIx7y7UWzriaNzb7zDogmKGkBEz4H4+ndq+6wibUCFmAuweniwxz+e+OIvyc/4CFSISQdwqqKK2LkfntM27A6Y8+425ry7rVmP2/7YBPy8mvf2l5qayqJFi5g4cWKbFWJ33303v/jFLxodExkZ2eztNqX9+ZlkZ2fzq1/9ytmk495772XIkCHNziLS0hrq3tjUrsSeXt54enlDYPA55cg5sIeqF0fUKQi971hFjyZmqaqspKKijMqKcqoqyqmoKKeqspyqigqqKsuoqqygqqKcqsoK7JU1/1ZgryrH8cO/ZSeOkJj5/2oVdXaHwcbev8biF1S9wnFaFVer8Y7jh/tO/9lR72NqxjkAHHbnY2p26yg9QeLhpVh+cmTuFN74GWV05Shdy45CWTocA36cmUsuwRz16kaxfw+qgnrjHdaPwG4DCO8Vgy2gc5P+vxRxRSrEXER5j3GQ+SUBh742O4qI/ITdbueuu+5ixowZJCYmcvPNN1NRUYGnp2eTt3Ho0CEefvhhli5d2uTHBAcHExx8bn8MtpZRo0aRnp5udgyRejWle2NrO9eCEKq/qLV6eMA5tulP+Y9PnRyjTTlHrH+dHCOvuo+83IPkZWdy8vAuKvP24FWwl4BT+wmvPEgAJdWXNSjPh/KtcBzI+nGbxwjkqGc3Tvp1pzKoN56hfQmIHEB4r1gCg0MbzKKmIeIKVIi5iK7xEyBzPtFl2zhVfFKH4aXd8/W0sv2xCc16zJGCUpKe+hz7adNvLAZ8MvMCIgKbft6Zr6e1Wft97rnnyMvL47HHHmPfvn1UVFSwY8eOZh0BioyMbFYRBq03NdGV25+LtJSz7d7YklyhIHSHHCER3QmJ6A5cUmu8w27nRH4uOXu3c/LQLiryvsejIItOxfsJqzxIMIV0oYAuFQVQsB0KgOwfH38CG7kekRT69aAisBceIX3pFNmfE7u+ZuSup9Q0REynQsxFdO83lFyCCTPy2Zr6CUPGXWV2JJFWZRhGs6cH9gm1seDqIfzuvxlUORxYDYP5Vw+mT6itlVLCwYMHmTNnDm+88Qb+/v5ER0fj7e1NRkYGQ4YMYe/evUyePJnBgweTkpJCUlISEyZMYMGCBRQXF7N8+XKio6PZu3cv1157Le+88w6TJ08mLi6OlJQUhg4dyptvvlnvOWutNTXR1dufi7QnrlAQumsOw2IhKCSCoJAIoO5pG4UnjpGbnUnBwZ1U5O7BciILW/E+QisOEspxgigiqHIXFO6CQmA/UHPa3g9vuVbDQcK3j5DeOZKYMZeraYi0KRViLsKwWMgOHEVYwWqKMteCCjGRel0/sgfj+oeyN6+EXiF+rd418b777iM5OZmJEycC4OHhQUxMTK3zxDIzM3nrrbfo168fgwcPxmazsXHjRl544QWef/55nnnmmVrbzMzM5I033iAmJoYLL7yQL7/8krFjx9bZ99lOTTxT63OgQ7U/F5H2KSCoCwFBP4NhP6tzX/HJE+Rk76Tg4A7Kcr7DciIL/6J9dC3PIpjCWmMthoO4dXdS/rmV3R69yQ+Mha5xdOmfSI+BCXh5n1unX5GGqBBzJX0ugC2rCTnatK5lIh1V10DfNmlbv2rVKtauXUtmZmat9UOGDKlViA0YMIABAwYAEBMTQ1JSknPc+++/X2e7AwYMIDY2FoD4+Hj27t1bbyF2tjZv3lyr9fnMmTOB2q3Pr7/+eo4ePcrcuXOd7c9Xr16t64CJSLvg3ymIPoMTYXDtSzrU10TF4YCThi8Bximiq76D/O8gfyVsg3KHB7s9q4szo2scwdGJ9Bg4QsWZtAgVYi6k18jLYMts+lZ8R8GxHAK76A8iETNdfvnlHD9+vM761157rdZtb29v588Wi8V522KxUFVVt8306eOtVmu9Y85FU1qfg9qfi0jH01ATlZFX3ceh7F0c2bGesn1p2PK30rNsFwFGMdGVu+HYbjj2LmRUF2e7PPtwPDAWIzKOLj8UZ55e3mcOIHIaFWIuJDSyF9mW7vS07+f7zauJnzDF7EgiIiIi7UpDTUMiew8ksvdAoHqKtsNu5+DenRzZsYHy/ZvplJ9Bj7LdBBjF9K/cBcd2wbEVsBXKHJ7s8uz9Q3EWT5f+59FjQLyKM2mUCjEXcyR4FD3z9lO+ay2oEBMRERFpcU1pGmJYLHTrE0O3PjHULs4yObJjAxX7U7Hlb6NH2S4CjJJ6i7Odnn04ETQIS2Scszjz8PRy7kNt9Ds2w9GU+SvSqMLCQgIDAykoKCAgIOCctrXlo38T//V09huRdJ+XeeYHiLiJ0tJSsrKy6N27Nz4+mlvf0TT2+rfke6i0DL0mIk3nsNs5+P12cnZuoGJ/Gp3yM+hevpsASuqMLXV4ku3ZlxNBsRgVpxhxYjXWH9rop6qNfrvR1PdQHRFzMX1GXkrVVwbdOcSR/d8R0b2f2ZFEREREpAGGxUJUv8FE9RvsXGevqmJ/VnVxVrl/C53yt9KjbDedjFMMqNwBeTt+eHD1P1bDwfBvHyUncZKOjHUgKsRcTGDnEHZ5RtO/chf7Nn9ARPd7zY4kIiIiIs1gsVrp3m8I3fsNca6zV1Wx//tt5OzcgJG5ihHFn9d6jIdhJy97hwqxDsRidgCp61j4GAAsWZ+fYaSIiIiIuAOL1Ur36KEkXP4rom74G1UOo9b9lQ4LIT0HmpROzKBCzAV1irkYgJ6Fm3HY7SanEREREZGWFB7Vl9Shj2D/oRhzOOD18P/T0bAORoWYC+o34mJKHZ6Ecpx9O7eYHUdEREREWtioax6gYOILAOxzhPJi0c+w29VDryNRIeaCfHz92e1TfcLn4fQPTU4jIiIiIq2hc//RAERa8jmYX8wX3+WZnEjakgoxF1UUeT4A3vu/MDmJiIiIiLSKgG5g8cCTKsI5ztIN2WYnkjakQsxFdRlyCQD9irdQWVFuchoRERERaXEWKwR2B6CHkcuaHbkcLjhlcihpKyrEXFTfoedTiD+djFPs+eZLs+OIiIiISGvo3AuAcWHFVNkdLNu039w80mZUiLkoq4cHe/zjATie8YnJaURERESkVXTuCcDFEdVHwt5M2U9llbpmdwQqxFxYeY+xAHQ6pCNiIuJ6srKyuPDCC4mNjWXIkCEUFxebHUlExP38cEQs2vMYwf5eHCksZe2OXHMzSZtQIebCusZfCkC/su2UlhSZnEZEpLapU6fy2GOPsX37dj7//HO8vb3NjiQi4n6Cqo+IWQv2cV1CFABLN+4zM5G0ERViLqx7v6HkEoy3UcHuzWvMjiPSoc2aNQtvb29uvPFGs6O4hG3btuHp6cnYsdVH7oODg/Hw8DA5lYiIG/phaiLH93LDyB4ArNt9lP35JSaGkragQsyFGRYL2YEjASjK1HliImaaPXs2Tz75JG+88Qbfffed2XEatW7dOiZNmkRkZCSGYbBixYp6xy1cuJBevXrh4+NDYmIiKSkpTd7H7t27sdlsTJo0ieHDhzN//vwWSi8i0sF07l39b9ERegVaGBsdgsMBb6ToqFh7p0LM1fUZD0DI0fXm5hDp4AIDA7n99tuxWCxs3brV7DiNKi4uZtiwYSxcuLDBMcuWLWPmzJnMmzePtLQ0hg0bxoQJE8jN/fG8hLi4OAYPHlxnOXToEJWVlXzxxRf8/e9/Z/369Xz88cd8/PHHbfH0RETaF9/O4NWp+ucT+7gpsfqo2Fub91NeqaYd7ZkKMRfXa+RlAPSt+I6C/KMmpxHp2CorK/Hz8yMjI8PsKI1KTk7mT3/6E1dddVWDY5566inuvPNOpk2bRmxsLIsWLcLPz4+XX37ZOSY9PZ2MjIw6S2RkJN26dSMhIYHu3bvj7e3NZZddRnp6ehs8OxGRdsYwnA07OJ7NxTHhhHXyJq+onI+2HzE1mrQuFWIuLjSyF9mWKCyGg+83vW92HBHXUHAQstZV/9uG/vCHP1BUVNRmhdj8+fOx2WyNLvv2NX/qSnl5OampqSQlJTnXWSwWkpKSWL++aUffR44cSW5uLsePH8dut7Nu3TpiYmKanUVERPjxPLET2XhaLfxyZPVFnpdu0PTE9kxnVruBI8GJ9Mw7QPnuz2DCFLPjiLQMhwMqzuJE5PTX4YPfgMMOhgWS/wpxzWyg4elX/Q1kM6SmprJo0SImTpzYZoXY3XffzS9+8YtGx0RGRjZ7u3l5eVRVVREeHl5rfXh4ODt27GjSNjw8PJg/fz7jxo3D4XBwySWXcPnllzc7i4iIcNoRsb0AXD+qB89/+h3rvz/Gd7lF9AuzmRZNWo8KMTfg1f8iyPsPkcc2mB1FpOVUlMD85hcRtTjs8P5D1Utz/O4QePk3ebjdbueuu+5ixowZJCYmcvPNN1NRUYGnp2eTt3Ho0CEefvhhli5d2uTHBAcHExwc3OTxbS05OZnk5GSzY4iIuL+gHzsnAnQL8uWigWF8kpnLGyn7mHN5rHnZpNVoaqIb6DPyUqocBt0dh8g5sMfsOCIdznPPPUdeXh6PPfYYQ4YMoaKioslHjmpERkY2qwiD1puaGBISgtVqJScnp9b6nJwcIiIimr09cT379+9n/PjxxMbGMnToUN5++22zI4lIY5wt7LOdq25KrF73TuoBSiuqzEglrUxHxNxAYOcQdnlG079yF/s2f0B41AyzI4mcO0+/6iNTzVF4CBaOqj4SVsOwwvSNENCMo2uefk0eevDgQebMmcMbb7yBv78/0dHReHt7k5GRwZAhQ9i7dy+TJ09m8ODBpKSkkJSUxIQJE1iwYAHFxcUsX76c6Oho9u7dy7XXXss777zD5MmTiYuLIyUlhaFDh/Lmm29i1DNVsrWmJnp5eTFixAjWrFnDlVdeCVQf9VuzZg0zZuj9pT3w8PDg6aefJi4ujiNHjjBixAguu+wy/P2bfiRYRNpQzdTEE9nVU/cNg3H9Q+kW5MvBE6d4f+thrh4eZWpEaXkqxNzEsbDRcGgXxvefAfpDSdoBw2jW9EAAQqJh0jPwvwfAUVVdhE16unp9K7nvvvtITk5m4sSJQPUfuDExMbXOE8vMzOStt96iX79+DB48GJvNxsaNG3nhhRd4/vnneeaZZ2ptMzMzkzfeeIOYmBguvPBCvvzyS+eFkU93tlMTi4qKal3rLCsri/T0dIKDg+nRo7ot8syZM5kyZQoJCQmMGjWKp59+muLiYqZNm9bs/Ynr6dq1K127dgUgIiKCkJAQ8vPzVYiJuKqg6vdmygrh1HHwC8ZqMbhhVHee+GgXSzfuUyHWDmlqopvoFFvd3axn4WYcdl1TQjqw4bfCA1thyqrqf4ff2mq7WrVqFWvXrq1TSA0ZMqRWITZgwAAGDBiA1WolJibG2Y2w5ojZTw0YMIDY2FgMwyA+Pr7eMedi8+bNxMfHEx8fD1QXXfHx8cydO9c55vrrr+eJJ55g7ty5xMXFkZ6ezurVq+s08JDW0ZSLbp/LBbdPl5qaSlVVFd27dz/H1CLSajx9wfbD1PAfzhMD+EVCdzwsBqnZx8k8XGhONmk1blGIffbZZxiGUe+yadMmAB555JF67z/Tt3/79u1j4sSJ+Pn5ERYWxsMPP0xlZWVbPK1m6TfiYkodnoRynH270s2OI2KuwG7Qe2z1v63o8ssv5/jx43XOm3rttdd49913nbe9vb2dP1ssFudti8VCVVXdef2nj7darfWOORfjx4/H4XDUWZYsWVJr3IwZM8jOzqasrIyNGzeSmJjYojmkYWe66Pa5XnC7Rn5+Prfeeiv//Oc/W/05icg5Oq2FfY2wAB8uGVT9BdnrG9XKvr1xi6mJY8aM4fDhw7XWzZkzhzVr1pCQkADAQw89xN13311rzMUXX8zIkSMb3G5VVRUTJ04kIiKCr7/+msOHD3Prrbfi6enJ/PnzW/6JnAMfX38yfAYxuCydw1tW03PgcLMjiYjIWTpTx8nTL7gNsGjRIt577z1efvllZs2aBXDGC2iXlZVx5ZVXMmvWLMaMGXPGsWVlZc7bhYX65l2kzXXuBfs31joiBtVNO97feoTlWw4yK3kg/t5u8ee7NIFbHBHz8vIiIiLCuXTp0oV3332XadOmOU9wt9lstcbk5OSwfft2br/99ga3+9FHH7F9+3b+/e9/ExcXR3JyMn/84x9ZuHAh5eXlbfX0muxk5M8A8N7/hclJRESktbTEBbcdDgdTp07loosu4pZbbjnj+AULFhAYGOhcNI1RxARBdTsnAozu04XeIf4UlVWy8ptmNrkSl+YWhdhPrVy5kmPHjjV6UvlLL71E//796z0Bvsb69esZMmRIrXMiJkyYQGFhIdu2bWvwcWVlZRQWFtZa2kKXIZcA0LckncoK1ysURTqiXr16sXnzZuftd955h/HjxwNw3nnnsWrVqlrjfjr+iSeeYOrUqW0ZWVxcYxfcPnLkSJO28dVXX7Fs2TJWrFhBXFwccXFxbN26tcHxs2fPpqCgwLns37//nJ6DiJyFzrWvJVbDYjG4cVR1M4+lG7OR9sMtC7HFixczYcIEoqLq7x5TWlrK0qVLGz0aBnDkyJF6P+hq7muIWd8c9h16PoX4E0AJe775sk32KSIi7udnP/sZdrud9PR05zJkyJAGx3t7exMQEFBrEZE2dnoL+5+4ZkQUXh4WMg4W8u2BE20aS1qPqYXYrFmzGmzCUbP89KKpBw4c4MMPP2y0yFq+fDknT55kypQprZLbrG8OrR4e7PGv7oJ2POOTNtmniIi0LV1wW6SDqpmaeGI/2Gs3cQr29+KywdX//S/doKYd7YWphdiDDz5IZmZmo0ufPn1qPeaVV16hS5cuXHHFFQ1u96WXXuLyyy8/YxvmmnPJTldzu7EPOzO/OSzvUT3V0nb4qzbbp4iItJ3TL7hdo+aC26NHjzYxmYi0qoBIsHiCvQIK654LdtN51YXaym8OUXCqoq3TSSswte1KaGgooaGhTR7vcDh45ZVXnJ0N65OVlcWnn37KypUrz7i90aNH8+c//5nc3FzCwsIA+PjjjwkICCA2NrbJudpSRNylkLmA6NJtlJYU4eNnMzuSiIg005kuuq0Lbot0QBYrBHWH/O+rpycG1T71JaFnZ/qH29iVU8SKLQeZMqaXOTmlxbjVOWJr164lKyuLO+64o8ExL7/8Ml27dq23LfDy5csZOHCg8/Yll1xCbGwst9xyC9988w0ffvghf/jDH5g+fXqt6/y4kh7RQ8klGG+jgt2b15z5ASIi4nLOdNFtXXBbpIMKqr9hB4BhGNyUWH3/0o3ZOByONgwmrcGtCrHFixczZsyYWsXU6ex2O0uWLGHq1KlYrdY69xcUFLBz507nbavVyqpVq7BarYwePZqbb76ZW2+9lccee6zVnsO5MiwWsgOrr41WtEPniYmIuKOmXHRbF9wW6YBqGnYcr7874lXDu+HraWVXThGbs4+3XS5pFW51RbjXX3+90fstFkujjTOmTp1ap010z549ef/991siXtvpfQGkf0hIbtOuJyMiIiIibqCBFvY1Anw8uWJYJMs272fphmxG9gpuu2zS4tzqiJhU6znyMgD6VnxHQf5Rk9OIiIiISItopIV9jZvOq76m2PsZR8gv1nVl3ZkKMTcU1q032ZYoLIaDPZtWmx1HRERERFpCI+eI1RgaFcSQboGUV9r5T+qBtsklrUKFmJs6EjwKgIrda01OIiIiIiItouaIWFEOVJxqcNiNidVHxV5P2YfdrqYd7kqFmJvy6n8xAF3zN5qcRERERERahG9n8P7h+rQnGr5w8xXDIrF5e5CVV8z674+1UThpaSrE3FSfkZdS5TDoYT9IzoE9ZscRafcuuOACDMOos9x6661mRxMRkfbCMJo0PdHf24Or4rsB1a3sxT2pEHNTgZ1D2OMZDcC+zR+YnEakfXM4HGzZsoUnnniCw4cP11r+/ve/mx1PRETaE2fnxMYLrJrpiR9tyyG3sLS1U0krUCHmxo6Fja7+Ietzc4OItHO7d+/m5MmTjBs3joiIiFqLzWYzO56IiLQnzmuJ7W10WEzXAEb07Eyl3cFbmxu+fJO4Lre6jpjU1inmYjj0Kr0KNuGw2zEsqqvF/RQXFzd4n9VqxcfHp0ljLRYLvr6+Zxzr7+/f7Iypqal4eHgwdOjQZj9WRESkWZrQwr7GTYk9SM0+zhsp+7lnfD+sFqN1s0mL0l/ubqxfQhKlDk9COc6+XelmxxE5KzabrcHlmmuuqTU2LCyswbHJycm1xvbq1avecWcjLS2NqqoqunTpUmtbd911FwAhISF1HrN3714SEhJqrZs6dSqrVq0C4MCBA1x99dX07duXhIQErrvuOnJychrcnoiIdBBNOEesxmVDuhLk58nBE6dYt0vXlnU3KsTcmI+vP9/5DALgSPqHJqcRab/S0tK44YYbSE9Pr7UsWLDgrLbncDiYPHkyEydOZM+ePWzevJn77ruPo0f1ISoi0uE5pyZmg6Px1vQ+nlauHR4FqGmHO9LURDd3MvJ8yErHa986YLbZcUSaraioqMH7rFZrrdu5ubkNjrX8ZGru3r17zynX6dLS0vjzn/9Mv379WmR7a9aswWazcfvttzvXjR07tkW2LSIibi6ougkH5Sfh1HHwC250+A2JPXjpyyzW7sjl4IlTdAvybXS8uA4VYm6uy5AJkLWQviXpVFaU4+HpZXYkkWZpzjlbrTW2Md9//z0nTpxg2LBhLbI9gO3btzN8+PAW256IiLQjnj5gi4CiI3A864yFWN9QG6P7dGH998dYlrKPmZcMaKOgcq40NdHN9R16PoX4E0AJ32/92uw4Iu1OamoqAOHh4Rw5cqTWYrfbG3ycYdR/wnRD60VERJxOn57YBDedV30U7c1N+6moavizSVyLCjE3Z/XwYI9fHAD5335kbhiRdigtLQ2A6Ohounbt6lx69epFZWVlg4/r0qULx48fr7UuPz+fkJAQYmJi2LJlS6vmFhERN9a56Q07AC6JjSDE5kXuyTLWZOa0Xi5pUSrE2oHynuMAsB3+yuQkIu3PggULcDgcdZbS0lK8vBqeCmyz2QgKCuLrr6uPVB84cICtW7cyaNAgkpKSKCwsZMmSJc7xX375JRkZGa39dERExB00o4U9gJeHhV8kdAdg6cZ9rRRKWpoKsXYgIu5SAKJLt1Fa0nDjAxFpHcePHycqKsq5vPHGGwC8+uqrzJo1i7i4OK688kpeeOEFbDYbhmGwYsUKVqxYQd++fRk0aBDPPfccoaGhVFZW4u3tbfIzEhERUzWjhX2NG0b1wDDgi915ZB9r+Lqb4jrUrKMd6BE9lFyCCTPy2bp5DUPGTTY7kkiHUlVVVe/6wYMHs27dunrv69GjBytWrKiz/ptvvqF3794tGU9ERNxNM88RA+ge7McF/UP5bOdRXk/Zx+zkmNbJJi1GR8TaAcNiITtwJABFOz4xOY2InK1XXnmFG2+8kUceecTsKCIiYqaac8QK9oO9/i/76nNTYvXj3t58gLLKpj9OzKFCrL3ofQEAXXI3mBxERM7WtGnT2LZtG0lJSWZHERERM3XqChZPsFdC4cEmP+zCAaF0DfQhv7ic1RlHWjGgtAQVYu1Ez5GXAdCvYjcF+UdNTiMiIiIiZ81i/fHCzs2YnuhhtXD9SDXtcBcqxNqJsG69ybZEYTEc7Nm02uw4IiIiInIumtnCvsYvR/bAajFIycpnd87Jls8lLUaFWDtyJHgUABW715qcRERERETOSTNb2NeICPTh4oFhgI6KuToVYu2IZ/RFAHTN32hyEhERERE5J2fRwr7GTedVP/a/aQc4Va6mHa5KhVg70nfkpVQ5DHrYD5JzYI/ZcURERETkbJ1FC/saY/uF0D3Yl8LSSlZ9e6hlc0mLUSHWjgQGh7LHMxqAfZs/MDmNiIiIiJy1mnPEmjk1EcBiMbhxVPXjNT3RdakQa2eOhZ1X/UPW5+YGEREREZGzVzM1sSgHykua/fDrEqLwtBqk7z9BxsGCFg4nLUGFWDvTKab6+kM9CzbjsNtNTiMiIiIiZ8W3M3gHVv98ovlHtUJs3lw6uCsAr6foqJgrUiHWzvQbcTFlDk/CyGffrnSz44iIiIjI2TAM6FxzLbG9Z7WJG0dVP/7dLQcpKqtsoWDSUlSItTM+fjZ2+wwC4Ej6hyanERERM5WUlNCzZ08eeughs6OIyNk4yxb2Nc7rE0yfUH+Ky6tYseVgy+WSFqFCrB06GXk+AF77vjA5iUj7ccEFF2AYRp3l1ltvNTuaSIP+/Oc/c95555kdQ0TO1jm0sAcwDIObEn9s2uFwOFoomLQEFWLtUJchlwDQt2QLlRXlJqcRcX8Oh4MtW7bwxBNPcPjw4VrL3//+d7PjidRr9+7d7Nixg+TkZLOjiMjZOocW9jWuGd4Nbw8LmYcLSd9/okViSctQIdYO9R36MwrxI4ASvt/6tdlxRNze7t27OXnyJOPGjSMiIqLWYrPZzI4nbmjdunVMmjSJyMhIDMNgxYoVdcYsXLiQXr164ePjQ2JiIikpKc3ax0MPPcSCBQtaKLGImOIcpyYCBPl5cfnQSECt7F2NCrF2yOrhwR6/eACObf3I5DQijSsuLqa4uLjWdIny8nKKi4spKyurd6z9tI6gFRUVFBcXU1pa2qSxZyM1NRUPDw+GDh16Vo8X+ani4mKGDRvGwoUL671/2bJlzJw5k3nz5pGWlsawYcOYMGECubm5zjFxcXEMHjy4znLo0CHeffdd+vfvT//+/dvqKYlIazh9auI5TCu86bzqph3/++YQBSVn91koLU+FWDtV3mMsAJ0OfWVyEpHG2Ww2bDYbeXl5znWPP/44NpuNGTNm1BobFhaGzWZj374fv9FbuHAhNpuN22+/vdbYXr16YbPZyMzMdK5bsmTJWWVMS0ujqqqKLl26OPPabDbuuusuADw8PIiLi3Mup06dAuDAgQNcffXV9O3bl4SEBK677jpycnIACAkJOass0j4kJyfzpz/9iauuuqre+5966inuvPNOpk2bRmxsLIsWLcLPz4+XX37ZOSY9PZ2MjIw6S2RkJBs2bODNN9+kV69ePPTQQ7z44os89thjDeYpKyujsLCw1iIiLiDoh66J5UVQkn/Wm4nvHkRM1wDKKu38J+1AC4WTc6VCrJ2KiK8+JyC6dBulJUUmpxFxb2lpadxwww2kp6fXWmqmfQUFBdVa7+vri8PhYPLkyUycOJE9e/awefNm7rvvPo4ePWrysxFXV15eTmpqKklJSc51FouFpKQk1q9f36RtLFiwgP3797N3716eeOIJ7rzzTubOndvo+MDAQOfSvXv3c34eItICPH2gU/W1wM62YQfUNO2oLuqWbsxW0w4XoUKsneoRPZRcgvE2KvgudY3ZcUQaVFRURFFRUa0jRA8//DBFRUU8//zztcbm5uZSVFREjx49nOumT59OUVERixcvrjV27969FBUVERMT41w3derUs8qYlpbG+eefT79+/WotwcHBDT5mzZo1dY7UjR07lsGDB59VBuk48vLyqKqqIjw8vNb68PBwjhw50ir7nD17NgUFBc5l//79rbIfETkLzvPE9p7TZibHReLnZWXP0WI2Zp390TVpOR5mB5DWYVgsZAcmEFbwESczP4Gxk82OJFIvf3//Ouu8vLzw8vJq0lhPT088PT2bPLa5vv/+e06cOMGwYcMaHHPixAni4uIASEhI4KWXXmL79u0MHz682fsTaWlN+QLC29sbb2/v1g8jIs0X1BP2rT+nzokAnXw8mRzXjTdS9rF04z7O69OlhQLK2VIh1p71Hg/pH9Eld4PZSUTcVmpqKlD/0YiwsDAsFotzaqJISwgJCcFqtTrPJ6yRk5NDRESESalExDSdz+1aYqe7KbEHb6TsY3XGYfKKYgmx6QsYM2lqYjvWc+RlAPSt2E1Bvs5LETkbaWlpAERHR9O1a1fn0qtXLyorKxt8XExMDFu2bGmrmNKOeHl5MWLECNas+XFaud1uZ82aNYwePdrEZCJiihZoYV9jcLdAhnUPoqLKwTupatphNhVi7VhYt97ss3TDajjYs2m12XFE3NKCBQtwOBx1ltLS0nqnT9ZISkqisLCwVqfGL7/8koyMjDZILa6uqKjI2dwFICsri/T0dGdH0JkzZ/Liiy/y6quvkpmZyT333ENxcTHTpk0zMbWImCKo5Y6IAc6mHa9v3IfdrqYdZlIh1s4dDk4EoGL3WpOTiHQsNRfpXbFiBX379mXQoEE899xzhIaGmh1NXMDmzZuJj48nPr76mo8zZ84kPj7e2dnw+uuv54knnmDu3LnExcWRnp7O6tWr6zTwEJEOoOaIWMEBqGp4JkZTTRoaSScfD/bll/Dld3lnfoC0Gp0j1s55Rl8Eef8lIj/F7Cgi7dbp10A7XY8ePVixYkWzHiMdw/jx48/YPnrGjBl1rqUnIh1Qp65g9YKqcig8+OM5Y2fJ18vKNcOjWPL1XpZuzGZcf31BaBYdEWvn+o68lCqHQU/7AXIPZpkdR0RERESaw2L58cLOLXCeGPw4PfGTzFyOFJS2yDal+VSItXOBwaHs8YwGIHvT+yanEREREZFmc54n1jKFWHR4J0b1CqbK7mDZJl030CxuUYh99tlnGIZR77Jp0yYAHnnkkXrvr+9aQjW++eYbbrjhBrp3746vry8xMTE888wzbfW02syxsPOqf8j6zNQcIiIiInIWWrCFfY2bzqs+Kvbmpn1UVtlbbLvSdG5xjtiYMWM4fPhwrXVz5sxhzZo1JCQkAPDQQw9x99131xpz8cUXM3LkyAa3m5qaSlhYGP/+97/p3r07X3/9Nb/61a+wWq3tal6+bWASHHqNngWbcdjtGBa3qL9FREREBFq0hX2NSwdHEOzvxeGCUj7beZSkWDUDamtuUYh5eXnVuohlRUUF7777Lvfeey+GYQBgs9mw2WzOMd988w3bt29n0aJFDW73tttuq3W7T58+rF+/nv/+97/tqhCLTriYsjWehBn5ZO/+lp4D4syOJCIiIiJN1cIt7AG8PaxcNyKKF9Z9z9KN2SrETOCWh0ZWrlzJsWPHGr2eyksvvUT//v0ZO3Zss7ZdUFBAcHBwo2PKysooLCystbgyHz8bu30GAXBkywcmp5GOzm7X9IeOSK+7iMg5qDki1kLniNW4YVT19MTPdh1lf35Ji25bzswtjoj91OLFi5kwYQJRUVH13l9aWsrSpUuZNWtWs7b79ddfs2zZMt57771Gxy1YsIBHH320Wds228nI8yErHa99XwCzzY4jHZCXlxcWi4VDhw4RGhqKl5eX84i2tF8Oh4Py8nKOHj2KxWJp9CLYIiLSgJpzxIpzobwYvBrugdAcvUL8GRsdwhe783jio53MSh5I10DfFtn22ThccIqsvGJ6h/h3iBymFmKzZs3iL3/5S6NjMjMzGThwoPP2gQMH+PDDD3nrrbcafMzy5cs5efIkU6ZMaXKWjIwMJk+ezLx587jkkksaHTt79mxmzpzpvF1YWEj37t2bvC8zdBlyCWQtpG/JFqoqK7F6uGUNLm7MYrHQu3dvDh8+zKFDh8yOI23Mz8+PHj16YNE5qiIizefbGXwCobQATuyDsJgW23SvLn58sRveTT/E/745xOzkGCbHRbbY9pvq3fRDLPggE7sDLAYuk2PB1UO4fmSPVtmX4TjTFSVb0dGjRzl27FijY/r06VPrG9Q//vGPPPfccxw8eBBPT896H3PxxRcTEBDA8uXLm5Rj+/btXHjhhdxxxx38+c9/bvoT+EFhYSGBgYEUFBQQEBDQ7Me3harKSor/1J0ASth1xbv0Hz7e7EjSQTkcDiorK6mqqjI7irQRq9WKh4dHg0dA3eE9tKPRayLighaNhSPfwg3LYMClLbLJwwWnOP//rcVuWjXg+qyGwZezLmzWkbGmvoeaelgkNDSU0NCmX83b4XDwyiuvcOuttzZYhGVlZfHpp5+ycuXKJm1z27ZtXHTRRUyZMuWsijB3YfXwYI9fPPElX3Fs60egQkxMYhgGnp6eDf43LCIiIvXo3LO6EGvBhh1ZecX1FmEWgzY9fcDhcLhsjiqHg715Ja0yRdGt5qetXbuWrKws7rjjjgbHvPzyy3Tt2pXk5OQ69y1fvpzZs2ezY8cOoHo64kUXXcSECROYOXMmR44cAaq/vW1OgeguynuMhR1f0enQV2ZHEREREZHmaIUW9r1D/LEY1Co+zuYI0Lmq78icK+XoFeLXKvtzq8n6ixcvZsyYMbXOGTud3W5nyZIlTJ06FavVWuf+goICdu7c6bz9zjvvcPToUf7973/TtWtX59LYtcfcWUTcBACiS7dRWlJkchoRERERabJWaGHfNdCXBVcPwfrDUSerYTD/6sFt3iijo+Yw9Ryx9sJd5tI77HaOPtaXMPLJuPg1Bo+dbHYkERG3eQ/tSPSaiLig3Z/A0msgbBD8+usW3fThglPszSuhV4if6d0K20MOtzhHTNqWYbGQHZhAWMFHnMxcAyrERERERNxD59OOiDkc0ILnTnUN9DW18OmoOdxqaqK0gN4XANAld73JQURERESkyQK7AwZUFENJ413HxT3oiFgH0yMhGdJ/T9+K3RQczyOwc4jZkURE2lTv3r3PqgvXAw88wH333dcKiUREmsDTBzp1hZOH4Hg2+OtvOHenQqyDCY/qyz5LN3rYD/L9ptXEX3Kz2ZFERNrUkiVLzupxvXr1atEcIiLN1rnnD4VYFkSNMDuNnCMVYh3Q4eBEeuT9l/Jda0CFmIh0MBdccIHZEUREzk7nXrBvfYu2sBfz6ByxDsgz+iIAIvJTTE4iIiIiIk3WCi3sxTw6ItYB9R15KVVfG/S0HyD3YBZh3XqbHUlExFShoaENnjfm7e1N7969efTRR7nwwgvbOJmIyGlqLup8XEfE2gMVYh1QYHAouz37EV25m+xN7xPWbbrZkURETHX06NEG76uqqiIjI4Obb76ZrVu3tmEqEZGf6KwjYu2JpiZ2UHlho6t/yPrc3CAiIi7g6NGjbN++vc767du3k5+fz7Bhw3jwwQdNSCYicpqaI2IFB6Cq0tQocu5UiHVQtoFJAPQs2ITDbjc5jYiIuWbMmMHx48frrD9+/LizZf3UqVPbOJWIyE/YIsDqDY4qKDxodho5RyrEOqjohIspc3gSRj77dn9rdhwREVNlZWVx/vnn11l//vnnk5GRYUIiEZF6WCwQ1L36Z01PdHsqxDooHz8bu30GAXAkfbXJaUREzFXf0bAap06dasMkIiJnUDM9US3s3Z4KsQ6sqGv1t79e2etMTiIiYq6hQ4fWe6Hn1157jSFDhrR9IBGRhqiFfbuhrokdWOfBSbB3IX1L0qmqrMTqoV8HEemYnn32WSZPnsyrr77K8OHDAUhLS+PkyZOsWLHC3HAiIqdTC/t2Q395d2B9h/2MwlV+BFDMrm+/ov/wC8yOJCJiim7durF582bWrFnj7J6YnJxMUlKSyclERH5CLezbDRViHZiHpxd7/OKIL/maY1s/BBViItJBvf/++86f+/bti2EYBAYGUlJSgp+fn4nJRER+QueItRsqxDq48h7jYMfXdDr0ldlRRERM8/bbb9dZl5+fT0ZGBv/85z+5+OKLTUh1brKysrjtttvIycnBarWyYcMG/P39zY4lIueq5hyx4qNQXgxe+u/aXakQ6+Ai4ibAjv9HdOk2SkuK8PGzmR1JRKTNvfLKK/WuP3DgAFdffTUpKSltnOjcTZ06lT/96U+MHTuW/Px8vL29zY4kIi3BNwh8AqG0oPo8sfBYsxPJWVLXxA6uR/84jtIZb6OC71LXmB1HRMSlREVFUVFRYXaMZtu2bRuenp6MHTsWgODgYDzUkEmk/dD0xHZBhVgHZ1gs7A0cCUBpyqvkHNhjciIREdexfv16AgICWny769atY9KkSURGRmIYRr2dGRcuXEivXr3w8fEhMTGxWUfldu/ejc1mY9KkSQwfPpz58+e3YHoRMZ1a2LcL+npMcBjVvwYJJ9dQ9eIIUoY+wqhrHjA3lIhIGxo5ciSGYdRal5+fT+fOnXn11VdbfH/FxcUMGzaM2267jauvvrrO/cuWLWPmzJksWrSIxMREnn76aSZMmMDOnTsJCwsDIC4ujsrKyjqP/eijj6isrOSLL74gPT2dsLAwLr30UkaOHMnPf/7zFn8uImICtbBvF1SIdXA5B/Yw4vgH8MPfH1bDwYhvHyUncRLhUX3NDSci0kbeeeedWrcNw6BLly74+/uzbNkyYmNb9hyM5ORkkpOTG7z/qaee4s4772TatGkALFq0iPfee4+XX36ZWbNmAZCent7g47t160ZCQgLdu3cH4LLLLiM9Pb3BQqysrIyysjLn7cLCwuY+JRFpS2ph3y5oamIHdzR7O1bDUWud1bDz/Yf/wF5VZVIqEZG21bNnz1pLjx49nB0GH3744TbNUl5eTmpqaq1rmFksFpKSkli/fn2TtjFy5Ehyc3M5fvw4druddevWERMT0+D4BQsWEBgY6FxqCjgRcVE6R6xdUCHWwYX2jKXKYdRZP3r/i3w/fyTfrH0Lh91uQjIREdfgcDjOPKgF5eXlUVVVRXh4eK314eHhHDlypEnb8PDwYP78+YwbN46hQ4cSHR3N5Zdf3uD42bNnU1BQ4Fz2799/Ts9BRFpZUK/qf49nQxu/R0nL0dTEDi48qi8pQx9h+LeP4mHYqXJY2Oo3iuiSdPpV7YF1d5K5/m/YL5zDoDGXmR1XRKTN/fTcMXdxpumPp/P29lZ7exF3EtQdMKCiGIrzwBZqdiI5CyrEhFHXPEBO4iTysncQ0nMgcVF9OX70MFv/80fiDr9FTMV2+OgGtn4+HO8Jj9B/+AVmRxYRaVGhoaH1FlwOh4MTJ060aZaQkBCsVis5OTm11ufk5BAREdGmWUTERXl4Q0AkFB6snp6oQswtaWqiANVHxgadP9HZoKNzaFfOu/vvnLxrMxu7XEmFw8qQsjT6r7yCLX9NJmvbRpMTi4i0nKNHj5Kbm1tnOXr0aJtfR8zLy4sRI0awZs2P13a02+2sWbOG0aNHt2kWEXFhamHv9lSISaNCI3uReO+rHJ36NZsCL6XKYRBf8jU935rA5qeu4cB3GWZHFBFptqlTp1JSUmLa/ouKikhPT3d2PszKyiI9PZ19+/YBMHPmTF588UVeffVVMjMzueeeeyguLnZ2URQR+bGF/V4zU8g5UCEmTRLZeyAj/28ZB25YS5ptHBbDQULhJ0T8aywpz9zEkf3fmR1RRKTJ/vWvf1FUVOS8fc8999SZgljfNbpayubNm4mPjyc+Ph6oLrzi4+OZO3cuANdffz1PPPEEc+fOJS4ujvT0dFavXl2ngYeIdGBqYe/2mlyImf3tobiGngOHM/yh//HdVe/zje8oPAw7o46vIvilRDYsvIO8I+q0JSKu76edEJcuXUp+fr7zdk5ODgEBAa22//Hjx+NwOOosS5YscY6ZMWMG2dnZlJWVsXHjRhITE1stj4i4oZqpiWph77aaXIiZ/e2huJZ+w85n2G8/Zkfy22zzGoKXUcl5R9/G7x8jWP/P+yjIP2p2RBGRJquvRX1paakJSUREmsg5NVGFmLtqciFm9reH4poGJl5C7Kx1bL1oCbs8+uNnlDH60KsYzw5l/Su/pajwuNkRRUTOiru2rReRDqJmamLBAajSwRB3dNbniOnbQ6lhWCwMGXcV0b/byJYxC8my9CSAEkZnL6L8qaFsWPoYpaeKzY4pIlLL66+/TlpaWpt3RRQRaRG2CLB6g6MKCg+YnUbOQos269C3hx2bYbEQf8nN9PhdGptH/JUDRleCKeS83U9S+JfBbHz7CSrKy8yOKSLC2LFjmTdvHgkJCdhsNkpKSpg3bx6LFi1iw4YNtabii4i4JIsFgnpU/6yGHW6pWRd0fv311xk3bhxDhgxprTzSDlg9PEiYdBcVE6aS8r+/03Prc4RzjLBtf+Tg9n9yOP7/iL/sTqweup64iJjj888/B2D37t2kpqaSlpZGWloav/vd7zhx4oS+WBQR99C5FxzbrfPE3FST/xKu+fbw5MmTeHp6UllZybx58zj//POJi4sjNFRX9JbaPL28GXXN/1F62a/YsPxvRO/6J90cOXRLm8Xe9IUcT3yYuJ/fgmHRVRRExBzR0dFER0fzy1/+0rkuKyuLzZs3s2XLFhOTiYg0gVrYuzXDUd/JXo346beHaWlptb49rKqqapWgrqywsJDAwEAKCgrUsKQRxSdP8O1//8qgrCUEUH3O2G5rP079bDZDLrhaBZlIB6X3UNej10TETXz1LHw8BwZfA9e+bHYa+UFT30ObPTdM3x7K2fLvFMToKfMpOD6T9e/8iWEHXie66jv4/Ha2f/03uHgOXaKiOZq9ndCesYRH9TU7soiIiIjrUgt7t9bsI2JSl745PDvHcg6w+79/JP7If/A2qruWORxgGFDlMEgd+gijrnnA3JAi0ur0Hup69JqIuInD38AL48AvBH6zx+w08oOmvodqLpiYpkt4FOfd8wIn7tzIpoAkZxEGYDUcJHw7j/X/eoScA3pjEZHWt2vXLiordS0eEXEjNUfESvKgTN1e3Y0KMTFdeFRffBOn8tMmZRYDRu/5G+EvDSf7scFsWHgH6Wve1EWiRaRVxMTE8P3335sdQ0Sk6XwCwSeo+ucTmp7obtQ/XFxCaM9YqhwGVuPHmbJ2h8H31t70rsqip30/PY/uh6NvU7HOynavGAoif0bwkAn0ixunVvgics40U19E3FLnXnA4vfo8sfBBZqeRZtBfr+ISwqP6kjL0EYZ/+ygehp1Kh4W0ofMYdc0DFOQfZU/Ke1TsXktU/ga6kUNsRQZkZ0D2IgpX+fOd/3Aqel5AVMJldOujNyERERHpIDr3/KEQ22t2EmkmFWLiMkZd8wA5iZPIy95BSM+BjPqha2JgcCjDL50Kl04F4OD3mRxIfQ/PvZ/TrziVAIoZXvwFbP8Ctv+JQ0Y4+4PPwzP6IvqOmkhgsK5xJyIiIu1U0A/XEtPURLejQkxcSnhU3zO2re/WJ4ZufWKAh6iqrGRn+jryt35I4OGviC7bTiQ5RB57F469S9X6B9jlGc2x8PMJGHQJ0SMuwsvbp22ejIiIiEhrUwt7t+UWzTo+++wzDMOod9m0aRMAjzzySL33+/v7N2kfx44dIyoqCsMwOHHiRCs+G2lJVg8PBiRcxOhpfyH2d19S9uAe0se+wIbQ68i2dMdqOOhfuYvRB19h0Ec3UDm/B9/85RI2vP4nsjNTcdjtZj8FERERkbPX+YcjYpqa6Hbc4jpi5eXl5Ofn11o3Z84c1qxZw549ezAMg6KiIoqKarftvPjiixk5ciRLliw54z6uvPJKysvL+eCDDzh+/DhBQUFNzqfrrbiunAN7yN70Ppasz+hTmEIwhbXuzyWY7MBRGH0vpNeoiYREdHc+TheWFmkbrvIearFY2LFjB/379zctg6twlddERJrg2B54bjh4+sHvDlGnDbW0uaa+h7rF1EQvLy8iIiKctysqKnj33Xe59957MX74ZbPZbNhsNueYb775hu3bt7No0aIzbv8f//gHJ06cYO7cuXzwwQct/wTENNVTHe8F7sVeVcWebRs5+s1q/A98QXTpVsKMfMIKVkPaakj7LXusvSn2CGZwaRrhhoMqh0GKiReWVkEoIiIijQqMAgyoKIHio2ALMzuRNJFbFGI/tXLlSo4dO8a0adMaHPPSSy/Rv39/xo4d2+i2tm/fzmOPPcbGjRubfP2YsrIyysrKnLcLCwsbGS2uwmK10nfoGPoOHQNAaUkRWzevoSjzI8Jyv6Zv1ff0rcqCqiw47cLSI7+dx8lvF1Bm+FBueFFheFNheFFp8abS4kWVxZsqqzd2izd2Dx/sVh8cHt7g4Qse3hievhiePlg8fbF4+WH18sHq5YeHtw8e3n54efvh4e2Ht48fnj5+ePv64e3ty6blzzLi20dcoiAU6Qh++9vf0qVLF7NjiIg0j4c3BHSDwgPV54mpEHMbblmILV68mAkTJhAVFVXv/aWlpSxdupRZs2Y1up2ysjJuuOEGHn/8cXr06NHkQmzBggU8+uijzc4trsXHz8aQcZNh3GQAjuUcYNfKxxl9cEmtcYYBnSilE6XgoHoBqGrdfCMdP84usBoOhn/7KDmJk3RkTKSVLFiwwOwIIiJnp3PPHwqxvdB9pNlppIlMLcRmzZrFX/7yl0bHZGZmMnDgQOftAwcO8OGHH/LWW281+Jjly5dz8uRJpkyZ0ui2Z8+eTUxMDDfffHOzcs+ePZuZM2c6bxcWFtK9e/dmbUNcT5fwKPok30fVi6/WurB0lcNg56Wv420LpqKsmKqyUirLS6gqL8VeXoK9/BSOylIcFadwVJRCZSnGD4ulquyHpRSrvQwPezke9jI87eV4OsrwcpThSQXejnJ8KMdy2n5/OsXbw7CTl71DhZiIiIjUFtQTsr+CE3vNTiLNYGoh9uCDDzJ16tRGx/Tp06fW7VdeeYUuXbpwxRVXNPiYl156icsvv5zw8PBGt7127Vq2bt3KO++8A0BN35KQkBB+//vfN3jUy9vbG29v70a3Le6pwQtLj76s1fftsNspryinrLSEI3sz6fPfibUKQrvDIKTnwEa2ICIiIh2SWti7JVMLsdDQUEJDm36xXYfDwSuvvMKtt96Kp6dnvWOysrL49NNPWbly5Rm395///IdTp045b2/atInbbruNL774gr59ddSho2rowtKtzbBY8PL2wcvbh07Dziflux8LQoAqDEoK8wH9boqIiMhp1MLeLbnFdcRqrF27lqysLO64444Gx7z88st07dqV5OTkOvctX7681jTHvn37MnjwYOfSu3dvAGJiYggL04mOHVl4VF8GnT/R1GmAo655gGN3bmZb0r/Z6h2Hp2HH/p87KSstMS2TSHsxdepUSkr035KItBM1R8RO6IiYO3GrQmzx4sWMGTOmVjF1OrvdzpIlS5g6dSpWq7XO/QUFBezcubO1Y4q0mPCovgz62SS6TvsXxwmgb1UWaa/91uxYIm7vX//6V61rT95zzz2cOHGi1pjKyso2TiUicpaCfjgiVnAAqirMzSJN5hYXdHZ1uvCltIW0D//F8PUzsDsMdl62jJjECWZHEmkRZryHWiwWjhw54pz9EBAQQHp6uvO85JycHHr37t1hj5rpc03EzdjtML8rVJbCfekQ3NvsRB1aU99D3eqImEhHNnzCLWwKSsZiOAhcfS9FhcfNjiTSbtT3nWRpaakJSUREzoLFAkE9qn/WeWJuQ4WYiBsZOO3vHCaUSEcO21+ZbnYckXbN+Ok1JEREXFnN9ESdJ+Y2VIiJuJFOgcEcn/AcdofBqOPvseWjf5sdScRtvf7666SlpVFRofMpRKQdUAt7t6NCTMTNxI5OJqXrjQD0/Ho2x3IOmJxIxP2MHTuWefPmkZCQgM1mo6SkhHnz5rFo0SI2bNhQq5GHu/rb3/7GoEGDiI2N5b777qt3+qWItCNqYe92TL2OmIicnfipT5D116/obd/LllfvJPih9zAs+l5FpKk+//xzAHbv3k1qaippaWmkpaXxu9/9jhMnTrj9tMSjR4/y/PPPs23bNjw9PRk3bhwbNmxg9OjRZkcTkdaiFvZuR4WYiBvy9vHDcfU/KX/7MuJLvmbTiucYefX9ZscScTvR0dFER0fzy1/+0rnu+++/JzU1lS1btpiY7NxVVlY6G45UVFTo+pgi7V2Qjoi5G32FLuKm+gxOJK1fdcOO2G/mc/D7TJMTibQPffr04brrrmP+/Pmtto9169YxadIkIiMjMQyDFStW1BmzcOFCevXqhY+PD4mJiaSkpDR5+6GhoTz00EP06NGDyMhIkpKS6NvXvAvUi0gbqJmaWHIMyk6am0WaREfERNzYyBvmsv0va4ityGDfG7cR8dsvsHroP2uRxvTu3fusph4+8MAD3HfffS2Sobi4mGHDhnHbbbdx9dVX17l/2bJlzJw5k0WLFpGYmMjTTz/NhAkT2Llzp/PIVlxcXL0Xnf7oo4/w9fVl1apV7N27F19fX5KTk1m3bh3jxo1rkfwi4oJ8AsG3M5w6Xt2wI2Kw2YnkDPQXm4gbs3p4EHTTyxS9cgExFdtZ//qjjL71j2bHEnFpS5YsOavH9erVq8UyJCcnk5yc3OD9Tz31FHfeeSfTpk0DYNGiRbz33nu8/PLLzJo1C4D09PQGH//222/Tr18/goODAZg4cSIbNmxosBArKyujrKzMebuwsLC5T0lEXEFQz+pC7IQKMXegQkzEzUX2GkBK3O8Y9c0cRuxZyJ5vk+k7dIzZsURc1gUXXGB2hEaVl5eTmprK7NmznessFgtJSUmsX7++Sdvo3r07X3/9NaWlpXh6evLZZ5/xq1/9qsHxCxYs4NFHHz3n7CJiss694HC6Wti7CZ0jJtIOjJw8gy1+5+NlVGFZcTelp4rNjiQiZykvL4+qqirCw8NrrQ8PD+fIkSNN2sZ5553HZZddRnx8PEOHDqVv375cccUVDY6fPXs2BQUFzmX//v3n9BxExCRqYe9WVIiJtAOGxULPqS9yjEB627NJX/Kg2ZFExGR//vOfyczMZNu2bTz77LONnhfn7e1NQEBArUVE3JBa2LsVFWIi7URwWDf2/+wvAIw68ibbvnrP5EQicjZCQkKwWq3k5OTUWp+Tk0NERIRJqUTELaiFvVtRISbSjsQl3UBK8CQshoMuH99P4YljZkcSkWby8vJixIgRrFmzxrnObrezZs0aXZBZRBpXc0TseDY4HKZGkTNTISbSzgya9jwHjXAiOMrOV+4xO46I1KOoqIj09HRn58OsrCzS09PZt28fADNnzuTFF1/k1VdfJTMzk3vuuYfi4mJnF0URkXoFdgcMqDwFRblmp5EzUCEm0s74dwri5KXPU+UwGFnwIWmrl5gdSUR+YvPmzcTHxxMfHw9UF17x8fHMnTsXgOuvv54nnniCuXPnEhcXR3p6OqtXr67TwENEpBYPLwjoVv2zzhNzeSrERNqhgYmXkNLtVgB6b/gDeYf0ZiziSsaPH4/D4aiznH6NsxkzZpCdnU1ZWRkbN24kMTHRvMAi4j5On54oLk2FmEg7NWLKX9lj7UNnTnLwtdtx2O1mRxIREZHWphb2bkOFmEg75eXtg/XaFylzeDKsdBMp/3nK7EgiIiLS2pwt7PeamUKaQIWYSDvWKyaBLf3vA2BIxl/Z/91WkxOJiIhIq3K2sNfURFenQkyknRv1y9+zzWsYfkYZJW/eQWVFudmRREREpLV0ViHmLlSIibRzFquVLjcv5qTDlwGVO9j07zlmRxIREZHWUjM1sfAAVFWYGkUap0JMpAOI6BHNzhHzAEjY+yK7078wOZGIiIi0Cls4ePiAww4F+81OI41QISbSQYy4/C7SbBfgaVThtfJuSkuKzI4kIiIiLc0wdJ6Ym1AhJtJBGBYLfab+k6N0pqf9AOmvPGB2JBEREWkNamHvFlSIiXQgQSERHL7gCQDOO/o2W9e9a3IiERERaXHOFvY6IubKVIiJdDBDL7yWjV2uBCB87QMU5B81N5CIiIi0rCAdEXMHKsREOqAh055lvxFJGPnsXnK32XFERESkJamFvVtQISbSAfnZAimZuJBKh4WEwk/Y/N6LZkcSERGRllIzNVFHxFyaCjGRDmpAwkVs6nEbAP03zSP3YJbJiURERKRF1ExNPJUPZSfNzSINUiEm0oEl3DKf3R7RBFBMzmu3Ya+qMjuSiIiInCufAPANrv5Z0xNdlgoxkQ7M08sbr+teotThyZCyNDa9/VezI4mIiEhLUAt7l6dCTKSD6zkgjm9iHgRgaOZTZO9MNzeQiIiInDu1sHd5KsREhJHX/YZvfUbga5RT/vYdVJSXmR1JREREzoVa2Ls8FWIigsVqJeKWxRTgT3Tlbjb/63dmRxIREZFzoRb2Lk+FmIgAENatN9+NfAyAkfteZufmtSYnEhERkbOmFvYuT4WYiDiNmHgHmztdjIdhx++96ZQUFZgdSURERM5GzdTEE/vA4TA3i9RLhZiI1BI97QVyCaa74xBblzxgdhwRERE5G4HdwbBA5SkoyjU7jdRDhZiI1BIYHErORU8DkJj3X7759G1zA4mIiEjzeXhBQLfqnzU90SWpEBOROoaMm8yG0OsA6Pb5Q5zIO2JyIhEREWk2tbB3aSrERKRecdOeJtsSRQgn2PvSLWR8sZKcA3vMjiUiIiJNpRb2Lk2FmIjUy8fPRvkVi6h0GMSVpjB4zS2EvDiClP88bXY0ERERaQq1sHdpKsREpEEBIZFY+LHTktVwMPzbR3VkTERExB2ohb1LUyEmIg06mr0di1F7nYdhJy97hzmBREREpOmcLex1RMwVuUUh9tlnn2EYRr3Lpk2bAHjkkUfqvd/f3/+M21+yZAlDhw7Fx8eHsLAwpk+f3tpPScQthPaMpcpRuxJzOKBTaJRJiURERKTJao6IFR6EynJTo0hdblGIjRkzhsOHD9da7rjjDnr37k1CQgIADz30UJ0xsbGxXHfddY1u+6mnnuL3v/89s2bNYtu2bXzyySdMmDChLZ6WiMsLj+pL6tBHqHRUv1U4HGAYcHz5Q1RW6A1dRETEpdnCwMMXHHYo2G92GvkJtyjEvLy8iIiIcC5dunTh3XffZdq0aRhG9bf1Nput1picnBy2b9/O7bff3uB2jx8/zh/+8Adee+01brzxRvr27cvQoUO54oor2uqpibi8Udc8wLE7N7Pt56+Tfv5CSh2eDDuVQtrCKTjsdrPjiXRoV111FZ07d+baa6+tc9+qVasYMGAA0dHRvPTSSyakExHTGcaPDTs0PdHluEUh9lMrV67k2LFjTJs2rcExL730Ev3792fs2LENjvn444+x2+0cPHiQmJgYoqKi+MUvfsH+/Y1/Y1BWVkZhYWGtRaQ9C4/qy6DzJxJ/yc3s+NmzVDkMRp14nw2vPGx2NJEO7f777+e1116rs76yspKZM2eydu1atmzZwuOPP86xY8dMSCgiplMLe5flloXY4sWLmTBhAlFR9Z+nUlpaytKlSxs9Ggbw/fffY7fbmT9/Pk8//TTvvPMO+fn5/PznP6e8vOFpVwsWLCAwMNC5dO/e/Zyej4g7ifv5jWwePAeA0ftfYuPbT5icSKTjGj9+PJ06daqzPiUlhUGDBtGtWzdsNhvJycl89NFHJiQUEdOphb3LMrUQmzVrVoNNOGqWHTtqd2c7cOAAH374YaNF1vLlyzl58iRTpkxpdP92u52KigqeffZZJkyYwHnnnccbb7zB7t27+fTTTxt83OzZsykoKHAuZzqCJtLeJF73IOu73wFAQsafSP/4dZMTibiedevWMWnSJCIjIzEMgxUrVtQZs3DhQnr16oWPjw+JiYmkpKS0yL4PHTpEt27dnLe7devGwYMHW2TbIuJm1MLeZXmYufMHH3yQqVOnNjqmT58+tW6/8sordOnSpdHzuF566SUuv/xywsPDG912165dAYiNjXWuCw0NJSQkhH379jX4OG9vb7y9vRvdtkh7d960x0l57jCjjr/HgC/vZ0dQGANHJpkdS8RlFBcXM2zYMG677TauvvrqOvcvW7aMmTNnsmjRIhITE3n66aeZMGECO3fuJCwsDIC4uDgqKyvrPPajjz4iMjKy1Z+DiLQDamHvskwtxEJDQwkNDW3yeIfDwSuvvMKtt96Kp6dnvWOysrL49NNPWbly5Rm3d/755wOwc+dO5zTH/Px88vLy6NmzZ5NziXREhsXC8F8v4ZunJjLsVAoR700hO+A9eg6IMzuaiEtITk4mOTm5wfufeuop7rzzTuf5zosWLeK9997j5ZdfZtasWQCkp6ef1b4jIyNrHQE7ePAgo0aNanB8WVkZZWVlzts691mkHXEeEVMh5mrc6hyxtWvXkpWVxR133NHgmJdffpmuXbvW++G3fPlyBg4c6Lzdv39/Jk+ezP3338/XX39NRkYGU6ZMYeDAgVx44YWt8hxE2hMPTy+ip7/DLo/+BFGE1xvXkndIb/QiZ1JeXk5qaipJST8eRbZYLCQlJbF+/fpz3v6oUaPIyMjg4MGDFBUV8cEHHzR6aRad+yzSjtWcI3YqH0r1JYsrcatCbPHixYwZM6ZWMXU6u93OkiVLmDp1Klartc79BQUF7Ny5s9a61157jcTERCZOnMgFF1yAp6cnq1evbvCIm4jU5mcLJORXKzhgdKUrRylYPJmTBflmxxJxaXl5eVRVVdWZQh8eHs6RI0eavJ2kpCSuu+463n//faKiopxFnIeHB08++SQXXnghcXFxPPjgg3Tp0qXB7ejcZ5F2zLsT+P3w37+mJ7oUU6cmNtfrrzfeEMBisTT64TF16tQ656QFBASwePFiFi9e3BIRRTqk4LBunLplOcdem0Dfqiwy/n4V/Wd+iJe3j9nRRNq1Tz75pMH7rrjiiiZfF1PnPou0c0E9oeRYdcOOiCFmp5EfuNURMRFxXd36xJB/5VKKHT4MLkvn24U3Ya+qMjuWiEsKCQnBarWSk5NTa31OTg4REREmpRKRdkst7F2SCjERaTHRcWP5/qJ/UOGwklD4CSkv3mt2JBGX5OXlxYgRI1izZo1znd1uZ82aNYwePdrEZCLSLqmFvUtSISYiLWrIBVeTHv9HAM47spQNr//J5EQi5igqKiI9Pd3Z+TArK4v09HTn5VFmzpzJiy++yKuvvkpmZib33HMPxcXFzi6KIiItRi3sXZJbnSMmIu5h5JXTWV9wiNFZzzNq5xOkvt+VEZc1fBF2kfZo8+bNtTrwzpw5E4ApU6awZMkSrr/+eo4ePcrcuXM5cuQIcXFxrF69+ozXwBQRaTa1sHdJhsPhcJgdwt0VFhYSGBhIQUEBAQEBZscRcQkOu52Uv99OYt5/KXd4sPuS1xh0/kSzY4kL0nuo69FrItLO5H8Pz8aDhw/8/ggYhtmJ2rWmvodqaqKItArDYiHh7hdJ8x+Ll1FJ94/vIGvbRrNjiYiIdDyB3cGwQGUpFOWceby0CRViItJqrB4exE5/k0zPQQRQgv/bv+TIvt1mxxIREelYrJ4QEFX9sxp2uAwVYiLSqnz8bETe8y57Ld0JI5/SJVdRcEzfxomIiLQptbB3OWrWISKtLjA4lFPTVpC7+Of0su8nc9FVeM/8GB9ff7Ojicg5qKqqoqKiwuwY0kY8PT2xWq1mx5Cz1bkn7P1CR8RciAoxEWkTEd37kXXdmxS+fSUxFdtIe/56hv3fCqweehsScTcOh4MjR45w4sQJs6NIGwsKCiIiIgJDzR7cT1Cv6n/Vwt5l6C8gEWkzvQclsu3ES0R/dCvDi79g46I7GfXrxRgWzZIWcSc1RVhYWBh+fn76o7wDcDgclJSUkJubC0DXrl1NTiTNphb2LkeFmIi0qUHnTyS14K/Eb3yQxLz/sv5fkYye8mezY4lIE1VVVTmLsC5dupgdR9qQr68vALm5uYSFhWmaortxniO219QY8iN9DS0ibW7EZbeTMuAhAEZnPc+mFQtNTiQiTVVzTpifn5/JScQMNa+7zg10Q0E/FGKFB6Gy3NwsAqgQExGTnHfjH9gQcRMAcVvm8O1n/zE5kYg0h6Yjdkx63d2YLQw8fAEHFOw3O42gQkxETDTqzufYHJCEp1FFv0/vYXf6F2ZHEhERaZ8MQ9MTXYwKMRExjcVqZej0pWR4x+FnlBG84iYOfp9pdiwREZH2ydmwY6+ZKeQHKsRExFRe3j70/PVy9lj70IUCHP+6ivzcg2bHEhERaX9qzhNTC3uXoEJMREzXKTCYwNtXcJhQohyHyfvnlZQUFZgdS0Sk3Ttx4gQJCQnExcUxePBgXnzxRbMjSWtSC3uXokJMRFxCSGRPKm58hxPY6F+5i90Lr6OyQl2dRERaU6dOnVi3bh3p6els3LiR+fPnc+zYMbNjSWvROWIuRYWYiLiMHv3jODLxVUodngw7tZG0hVNw2O1mxxKRdmTWrFl4e3tz4403mh3FJVitVmdL+rKyMhwOBw6Hw+RU0mo0NdGlqBATEZcycGQSO372LFUOg1En3mfDKw+bHUlE2pHZs2fz5JNP8sYbb/Ddd9+ZHadR69atY9KkSURGRmIYBitWrKh33MKFC+nVqxc+Pj4kJiaSkpLSrP2cOHGCYcOGERUVxcMPP0xISEgLpBeXVHNE7NRxKNUpAGZTISYiLifu5zeyefAcAEbvf4mNbz9hciIRaS8CAwO5/fbbsVgsbN261ew4jSouLmbYsGEsXNjwRe+XLVvGzJkzmTdvHmlpaQwbNowJEyaQm5vrHFNz/tdPl0OHDgEQFBTEN998Q1ZWFq+//jo5OTmt/tzEJN6dwK9L9c86T8x0KsRExCUlXvcg67vfAUBCxp9I//h1kxOJSEs7XHCKr/fkcbjgVJvut7KyEj8/PzIyMtp0v82VnJzMn/70J6666qoGxzz11FPceeedTJs2jdjYWBYtWoSfnx8vv/yyc0x6ejoZGRl1lsjIyFrbCg8PZ9iwYXzxha7p2K6phb3L8DA7gIhIQ86b9jgpzx1m1PH3GPDl/Wxx2PH0DyS0ZyzhUX3NjicigMPh4FRFVbMf95/UA8xbuQ27AywGPHrFIK4ZEdWsbfh6WjEMo9n7/sMf/kBRUVGbFWLz589n/vz5jY7Zvn07PXr0aNZ2y8vLSU1NZfbs2c51FouFpKQk1q9f36Rt5OTk4OfnR6dOnSgoKGDdunXcc889zcohbiaoJxxM1XliLkCFmIi4LMNiYfivl/DNUxMZdiqFuK+mYxhQ5TBIGfoIo655wOyIIh3eqYoqYud+eE7bsDtgzrvbmPPutmY9bvtjE/Dzat6fMqmpqSxatIiJEye2WSF2991384tf/KLRMT89OtUUeXl5VFVVER4eXmt9eHg4O3bsaNI2srOz+dWvfuVs0nHvvfcyZMiQZmcRN6IW9i5DhZiIuDQPTy86X/UEjqXjqPni22o4GP7to+QkTtKRMRFpMrvdzl133cWMGTNITEzk5ptvpqKiAk9PzyZv49ChQzz88MMsXbq0yY8JDg4mODj4bCK3ulGjRpGenm52DGlLamHvMlSIiYjLKzy6j5/OPvIw7ORl71AhJmIyX08r2x+b0KzHHCkoJempz7Gf1iXdYsAnMy8gItCnWftujueee468vDwee+wx9u3bR0VFBTt27GjWEaDIyMhmFWHQelMTQ0JCsFqtdZpr5OTkEBER0axtSQeiFvYuQ4WYiLi80J6xVDkMrMaPf7U5HOAXpBbLImYzDKPZ0wP7hNpYcPUQfvffDKocDqyGwfyrB9Mn1NZKKeHgwYPMmTOHN954A39/f6Kjo/H29iYjI4MhQ4awd+9eJk+ezODBg0lJSSEpKYkJEyawYMECiouLWb58OdHR0ezdu5drr72Wd955h8mTJxMXF0dKSgpDhw7lzTffrPectdaamujl5cWIESNYs2YNV155JVB91G/NmjXMmDGj2duTDuL0qYl2O1jUu88sKsRExOWFR/UlZegjDP/2UTwMOw4HGAZULp9OYbcPCQjqYnZEEWmm60f2YFz/UPbmldArxI+ugb6tur/77ruP5ORkJk6cCICHhwcxMTG1zhPLzMzkrbfeol+/fgwePBibzcbGjRt54YUXeP7553nmmWdqbTMzM5M33niDmJgYLrzwQr788kvGjh1bZ99nOzWxqKio1rXOsrKySE9PJzg42Hn0bObMmUyZMoWEhARGjRrF008/TXFxMdOmTWv2/qSDCIwCwwJVZVCUAwFdzU7UYakQExG3MOqaB8hJnERe9g7s9kqi1kwnunI3mQsvx+P+1fjZAs2OKCLN1DXQt9ULMIBVq1axdu1aMjMza60fMmRIrUJswIABDBgwAICYmBiSkpKc495///062x0wYACxsbEAxMfHs3fv3noLsbO1efNmLrzwQuftmTNnAjBlyhSWLFkCwPXXX8/Ro0eZO3cuR44cIS4ujtWrV9dp4CHiZPWsLsZO7Ks+T0yFmGlUiImI2wiP6us8J+y7gBCsy68lpmI7Gc9dQb/738PHr/WmNYmI+7r88ss5fvx4nfWvvfZardve3t7Ony0Wi/O2xWKhqqpui/7Tx1ut1nrHnIvx48fjcDjOOG7GjBmaiijNE9SzuhA7kQ09R5udpsPSpFARcUv9hp3P4cv/TbHDh8Fl6ex89krKSkvMjiUiIuL61MLeJagQExG3NSDhYrIvXcIphxfDSjex/bnrqKwoNzuWiIiIa1MLe5dgOJpyzFsaVVhYSGBgIAUFBQQEBJgdR6TD2bpuOQPW3IGXUcnmgCTi71uG1UMzr92F3kNdT2OvSWlpKVlZWfTu3Rsfn6a3mpf2Qa9/O/Ht2/DfO6Dn+TCt7vmPcm6a+rmmI2Ii4vaGjLuK7WOfp8JhJaHwE1IX3oq9hc/VEHFVV111FZ07d+baa6+ttX7//v2MHz+e2NhYhg4dyttvv21SQhFxOc6piXvNTNHhqRATkXYhLukGvk18kiqHwajj75Hyjztx2O1mxxJpdffff3+dphNQ3Z796aefZvv27Xz00Uc88MADFBcXm5BQRFxOzdTEwkNQWWZulg5MhZiItBsjLptG2vD52B0G5+X9hw3/nKFiTNq98ePH06lTpzrru3btSlxcHAARERGEhISQn5/fxulExCX5h4KnH+CAE/vNTtNhqRATkXZl5ORfs2nwHABGH1nKhld+Y3Ii6cjWrVvHpEmTiIyMxDAMVqxYUWfMwoUL6dWrFz4+PiQmJpKSktLiOVJTU6mqqqJ79+4tvm0RcUOGUd3CHuDEXlOjdGQqxESk3Um87kE29H8YgNH7X2T9a3NMTiQdVXFxMcOGDWPhwoX13r9s2TJmzpzJvHnzSEtLY9iwYUyYMIHc3FznmLi4OAYPHlxnOXToUJMy5Ofnc+utt/LPf/6zRZ6TiLQTamFvOrUVE5F26bwb/8D6V08xOut5Rn//LBve8OW8G35ndizpYJKTk0lOTm7w/qeeeoo777yTadOmAbBo0SLee+89Xn75ZWbNmgVAenr6We+/rKyMK6+8klmzZjFmzJhGx5WV/XieSGFh4VnvU0TchFrYm05HxESk3Ro95c9siLodgPN2/oWN//mbyYlEflReXk5qaipJSUnOdRaLhaSkJNavX3/O23c4HEydOpWLLrqIW265pdGxCxYsIDAw0LloCqNIB+CcmqgjYmZRISYi7VribU+wIfwGAEZ++yibVi4yOZFItby8PKqqqggPD6+1Pjw8nCNHjjR5O0lJSVx33XW8//77REVFOYu4r776imXLlrFixQri4uKIi4tj69at9W5j9uzZFBQUOJf9+3Xyvki7pxb2ptPURBFp1wyLhcS7/s7GhaUkHltOfOps0rx8GH7pVLOjibSITz75pN71P/vZz7A3sWuot7c33t7eLRlLRFydc2qijoiZRUfERKTdMywWRv56MZuCkvEw7AxeP5Nv1r5pdizp4EJCQrBareTk5NRan5OTQ0REhEmpRKTDqJmaWHoCTp0wM0mHpUJMRDoEi9XK8Bn/JrXThXgZVQz8fAZb171rdizpwLy8vBgxYgRr1qxxrrPb7axZs4bRo0ebmExEOgRvG/iFVP+s88RM4RaF2GeffYZhGPUumzZtAuCRRx6p935/f/9Gt71p0yYuvvhigoKC6Ny5MxMmTOCbb75pi6clIm3M6uHB0HuXscXvfLyNCvquuZPtG1abHUvasaKiItLT052dD7OyskhPT2ffvn0AzJw5kxdffJFXX32VzMxM7rnnHoqLi51dFEXaQlZWFhdeeCGxsbEMGTKE4uJisyNJW1ELe1O5RSE2ZswYDh8+XGu544476N27NwkJCQA89NBDdcbExsZy3XXXNbjdoqIiLr30Unr06MHGjRv58ssv6dSpExMmTKCioqKtnp6ItCFPL29i73uHb31G4meU0eODqexM/dTsWNJObd68mfj4eOLj44Hqwis+Pp65c+cCcP311/PEE08wd+5c4uLiSE9PZ/Xq1XUaeIi0pqlTp/LYY4+xfft2Pv/8c50v2JGohb2p3KIQ8/LyIiIiwrl06dKFd999l2nTpmEYBgA2m63WmJycHLZv387tt9/e4HZ37NhBfn4+jz32GAMGDGDQoEHMmzePnJwcsrP1zYBIe+Xt40f/+1awzWsYNuMUXf93E3u+/drsWNIOjR8/HofDUWdZsmSJc8yMGTPIzs6mrKyMjRs3kpiYaF7gDmDWrFl4e3tz4403mh3FJWzbtg1PT0/Gjh0LQHBwMB4e6uXWYaiFvancohD7qZUrV3Ls2LFGp2689NJL9O/f3/nGUp8BAwbQpUsXFi9eTHl5OadOnWLx4sXExMTQq1evBh9XVlZGYWFhrUVE3IuPn41e965kh2cMARQT/N/ryc5MNTuWiLSy2bNn8+STT/LGG2/w3XffmR2nUevWrWPSpElERkZiGAYrVqyod9zChQvp1asXPj4+JCYmkpKS0uR97N69G5vNxqRJkxg+fDjz589vofTiFtTC3lRuWYgtXryYCRMmEBUVVe/9paWlLF26tNGjYQCdOnXis88+49///je+vr7YbDZWr17NBx980Oi3QbrwpUj74N8piMjp77Hb2o/OFOK37Br2f5dhdiwRaUWBgYHcfvvtWCyWBq+r5iqKi4sZNmwYCxcubHDMsmXLmDlzJvPmzSMtLY1hw4YxYcIEcnNznWPi4uIYPHhwneXQoUNUVlbyxRdf8Pe//53169fz8ccf8/HHH7fF0xNXoBb2pjK1EJs1a1aDTThqlh07dtR6zIEDB/jwww8bLbKWL1/OyZMnmTJlSqP7P3XqFLfffjvnn38+GzZs4KuvvmLw4MFMnDiRU6dONfg4XfhSpP0ICOpC6D3vkWXpSSjH8fz3ZA5n7zQ7lkjHUHAQstZV/9uGKisr8fPzIyPDtb94SU5O5k9/+hNXXXVVg2Oeeuop7rzzTqZNm0ZsbCyLFi3Cz8+Pl19+2TkmPT2djIyMOktkZCTdunUjISGB7t274+3tzWWXXeZsLiMdQM0RsRPZ0MTrDkrLMXUS8IMPPsjUqVMbHdOnT59at1955RW6dOnCFVdc0eBjXnrpJS6//PIznuz8+uuvs3fvXtavX4/FYnGu69y5M++++y6//OUv632cLnwp0r4EhURQ+av32P/CJXR3HOLgkknk3vEhYd16mx1NxPU5HFBR0vzHpb8OH/wGHHYwLJD8V4hr5nlbnn7ww7nizfGHP/yBoqKiNivE5s+ff8Ypf9u3b6dHjx7N2m55eTmpqanMnj3buc5isZCUlMT69eubtI2RI0eSm5vL8ePHCQwMZN26ddx1113NyiFuLCAKDCtUlUPREQiINDtRh2JqIRYaGkpoaGiTxzscDl555RVuvfVWPD096x2TlZXFp59+ysqVK8+4vZKSEiwWi7PhB+C8bde3AiIdSkhEd3Jvf49Diy+lmyOH7MWXk3fXh4SE1z8FWkR+UFEC88/xjzeHHd5/qHppjt8dAq/GL1PzU6mpqSxatIiJEye2WSF2991384tf/KLRMZGRzf//MC8vj6qqqjpfPIeHh9eZUdQQDw8P5s+fz7hx43A4HFxyySVcfvnlzc4ibsrqAYFR1UfEjmerEGtjbnWO2Nq1a8nKyuKOO+5ocMzLL79M165dSU5OrnPf8uXLGThwoPP2z3/+c44fP8706dPJzMxk27ZtTJs2DQ8PDy688MJWeQ4i4rrCovrAlP+RQxd62g9Q+MJECo7lmB1LRFqI3W7nrrvuYsaMGdx6663s3r272ZerOXToEDfddFOzHhMcHEy/fv0aXczsVJicnMzWrVvJyMjgqaeeMi2HmEQt7E3jVv1JFy9ezJgxY2oVU6ez2+0sWbKEqVOnYrVa69xfUFDAzp0/nvsxcOBA/ve///Hoo48yevRoLBYL8fHxrF69mq5du7ba8xAR1xXZawD7b36XvH9fTh/7Xnb/YyLGjA8JCOpidjQR1+TpV31kqjkKD8HCUdVHwmoYVpi+sXnfyHv6NWu3zz33HHl5eTz22GPs27ePiooKduzYwZAhQ5q8jcjISJYuXdqs/bbW1MSQkBCsVis5ObW/MMrJySEiIqJZ25IOTC3sTeNWhdjrr7/e6P0Wi6XRxhlTp06tc07az3/+c37+85+3RDwRaSe69xtC9vX/wbrsSqIrd5O58HKs932Af6cgs6OJuB7DaPb0QEKiYdIz8L8HwFFVXYRNerp6fSs5ePAgc+bM4Y033sDf35/o6Gi8vb3JyMhgyJAh7N27l8mTJzN48GBSUlJISkpiwoQJLFiwgOLiYpYvX050dDR79+7l2muv5Z133mHy5MnExcWRkpLC0KFDefPNN2ud7lCjtaYmenl5MWLECNasWcOVV14JVH8pvWbNGmbMmNHs7UkHpRb2pnGrQkxEpK30jEngu6uWYV1+LTEV28l4bjL9HngPHz+b2dFE2ofht0LfiyH/ewjuA4HdWnV39913H8nJyUycOBGoPjcqJiam1nlimZmZvPXWW/Tr14/Bgwdjs9nYuHEjL7zwAs8//zzPPPNMrW1mZmbyxhtvEBMTw4UXXsiXX35Z7/VLg4ODCQ4ObnbmoqKiWtc6y8rKIj09neDgYOfRs5kzZzJlyhQSEhIYNWoUTz/9NMXFxY1ea1WkFmchpiNibU2FmIhIA/oNO5+dFf/G+r8bGVyezjfPXsnAB1bi7dO86VAi0oDAbq1egAGsWrWKtWvXkpmZWWv9kCFDahViAwYMYMCAAQDExMSQlJTkHPf+++/X2e6AAQOIjY0FID4+nr1799ZbiJ2tzZs31zpnfebMmQBMmTKFJUuWAHD99ddz9OhR5s6dy5EjR4iLi2P16tVn7Bwt4nR6C3tpUyrEREQaMSDhYraXv0LvD6cwrHQTW567jsEPLMfT08vsaCLSRJdffjnHjx+vs/61116rdfv0S9NYLBbnbYvFQlVVVZ3Hnz7earXWO+ZcjB8/HofDccZxM2bM0FREOXs154gVHoLKMvDQJZrailt1TRQRMUPsmMv47uIXKHd4EF/8JRlPXcnWde+Sc2CPqblyDuwh46v/KYeIiJw9/xDw8AEccGCzuVlMusi7WTl0RKwFFRcX19ut0Wq14uPjU2tcQywWC76+vmc1tqSkpMFvzgzDwM/P76zGnjp1qtHrqvn7+5/V2NLS0ka/PWzOWD8/P+cJ0mVlZVRWVrbIWF9fX+fFvsvLyxttc9ycsT4+Ps7fleaMraiooLy8vMGx3t7ezhbIzRlbWVlJWVlZg2O9vLyc1+5rztiqqipKS0sbHOvp6YmXl1ezx9rtdk6dOtUiYz08PJzfajscDkpK6r8wbZ8RE0gv+hvDN95H/KmvcKz5kqIPDD4Nvhyv6AvqjLdYDLy9fjxqdqq04f/PmjPWMAx8vL0o3/Upo46twFZhx+6oP0fN2KZsF8DX58dvQZs6tnzXpww5shwbDqocBp8P/h0JV9b+Zv5M7xGNvc+JiEgr2/IvqPzh83fJREi4DfqMb/sc338Gm18GHIDhGjkMS3VjoeG3tsquDEdTjnlLowoLCwkMDGzw/ssuu4z33nvPedvf37/BP/YuuOACPvvsM+ft0NBQ8vLy6h2bkJDApk2bnLd79epFdnb983tjY2PZtm2b8/agQYPYvn17vWN79uzJ3r17nbdHjhzJ5s31f0MSEhLC0aNHnbfHjx/P559/Xu9YPz+/Wn9wTZw4sd459zVO/9W87rrreOeddxocW1RU5Pxjb+rUqbz66qsNjs3NzXVeSHz69On8/e9/b3BsVlYWvXr1AuDhhx/miSeeaHBsRkYGgwYNAuCRRx7h0UcfbXBsSkoKI0eOBODxxx/nN7/5TYNjP/30U8aPHw/AwoULG51+smrVKueJ6EuWLGn0ZO233nqL6667DoC333670Y5er7zyirPj6HvvvdfoxT6ff/55pk+fDsBnn33W6DX5/vrXv/Lwww8DsGnTJkaNGtXg2Hnz5vHII48AsG3bNgYPHtzg2IceeojHH38cgL1799K7d+8Gx/76179m4cKFABw9epSwsLAGx/7i2qt5I3YNFsNBcbkD24KTDY69NtaDt6/78QsN49HCBsdeFu3Bezf+ONZ/fiElDdTmF/S08tnUHwub0MdPkldS/9t4QqSFTXf+2Fyk19MnyS6of2xsqIVtv/5x7KC/F7H9aP1fqvQMNNj7QCfn7ZEvFrH5UP1jm/MeUVBQQEBAQL33Sduq+Vyr7zUpLS0lKyuL3r171/qSUToGvf7tTMFBeHpw7UtJSG2GFR7Y2qzzWRt7Dz2djoiJiDRRafEJLEbTvrs6aQSww7P/aWs2NDi2yLCxw/PH6yM6SAHq/1AsMfzIsvSgt33fmfMavuzwjHXerjDSgPqPkpYZ3rXGlhnfAPUfSawwPNnhGYt3VVGTcoiIiIvK31N/ERYaAz4NH2RocaUFcDSz7npXyOGoqu7u2gqNhXRErAXUVL2HDh2qt+rV1MT6x2pqoqYmutPURIBjR7Lp9toYrIajemwFVDosHJv2BeHd+tQa25z/7pv7HlF47BAhL47A+sOROag/R2u/R+Qc2EPIiyMor7Rj/2FofTnO9B5RWFhIZGSkjoi5EB0Rk4bo9W9n6jsidhZHgJSjNh0RM4G/v3+tPzgaG9ecbTbV6X9EteTY0/+Qa8mxzXkDb85Yb2/vWp2sWmqsl5eX8497s8Z6eno6i5yWHOvh4eEsylpyrNVqbfLvcHPGWiyWVhlrGEajY/37xpIy9BGGf/soHoYdb08L24bOY1T/IWfcdkv+d+8b1deZw9/LTqWjaTla+j0i/LQcHkbTctT3HtHSneZERKSJArvVf3H1tix+OnAOHRFrAU2tekWkfcg5sIe87B2E9BxIeFRf5TjHHHoPdT06IiYN0evfThUcbLOLq3eEHDoiJiLSSsKj+ppa+CiHuAJ9j9sx6XVvp9ro4urKUZsKsRZUXFxMp06dnOcf1Zz7c/o5KDXjoPY5RTXn8zR0rkhTxtac03H6OUU15/M0dK5IU8bWnNNx+jlFNefzNGfsT89BqTnvq75zipoy9vRzf06fylVz3ldD5wmdaezp5wmdfj5ZzevZnLFNee1b4vekvtezJX5Pal7Pc/09aei8w7P9PWno9TzX35PTX89z/T1p6PU829+T9v4eIe6j5r+tkpKSZk1Hl/ah5n2vqVPfRaRhuqBzC4qMjKzVav7xxx/HZrPVaTceFhaGzWZj374fu40tXLgQm83G7bffXmtsr169sNlsZGb+2MFlyZIl2Gw2fvnLX9YaGxsbi81mIy0tzblu2bJl2Gw2rrjiilpjR44cic1m44svvnCuW7VqFTabjaSkpFpjx40bh81m48MPP3SuW7t2LTabjdGjR9cam5ycjM1mY/ny5c51GzZswGazMWzYsFpjr7nmGmw2G0uXLnWu27p1Kzabjejo6Fpjb7nlFmw2G//85z+d6/bs2YPNZqNbt9rfWNx1113YbDaeeeYZ57rDhw9js9kICgqqNXbmzJnYbDbmz5/vXFdQUIDNZsNms9Vq5PH73/8em83G73//e+e6yspK59iCggLn+vnz52Oz2Zg5c2at/QUFBWGz2Th8+LBz3TPPPIPNZuOuu+6qNbZbt27YbDb27PnxIrn//Oc/sdls3HLLLbXGRkdHY7PZ2Lp1q3Pd0qVLsdlsXHPNNbXGDhs2DJvNxoYNP3bxW758OTabjeTk5FpjR48ejc1mY+3atc51H374ITabjXHjxtUam5SUhM1mY9WqVc51X3zxBTabzdmqv8YVV1yBzWZj2bJlznVpaWnYbDZiY2Nrjf3lL3+JzWZjyZIlznWZmZnYbDbnpQVq3H777dhsNmc7eoB9+/Zhs9nqtKWfMWMGNpvN2eYeIC8vz/l6nu63v/0tNput1iUJSkpKnGNPb/Dx6KOPYrPZ+O1vf1trGzVj9R5R9z3i9MtwiOuzWq0EBQWRm5vLsWPHOHXqFKWlpVra+XLq1CmOHTtGbm4uQUFB9V43VUSaR0fEREREpFkiIiKA6usySscSFBTkfP1F5NyoWUcLOL19fUREhKYdaWqipiZqaqKmJjbjPeL48eMEBwerWYcLaeqJ5lVVVY1efkPaF09PTx0JE2mCpr6HqhBrAer4JSJy9vQe6nr0moiInL2mvofqHDEREREREZE2pkJMRERERESkjakQExERERERaWPqmtgCak6zKywsNDmJiIj7qXnv1CnLrkOfayIiZ6+pn2sqxFrAyZMnAejevbvJSURE3NfJkycJDAw0O4agzzURkZZwps81dU1sAXa7nUOHDtGpUydnW+qmKiwspHv37uzfv9/UzlTKoRzKoRxm5XA4HJw8eZLIyEhnC34xlz7XlEM5lEM5Wv9zTUfEWoDFYiEqKuqcthEQEOASLYKVQzmUQznMyKEjYa5Fn2vKoRzKoRyt/7mmrx5FRERERETamAoxERERERGRNqZCzGTe3t7MmzcPb29v5VAO5VAO5RC35yq/D8qhHMqhHK6eQ806RERERERE2piOiImIiIiIiLQxFWIiIiIiIiJtTIWYiIiIiIhIG1MhJiIiIiIi0sZUiJlkwYIFjBw5kk6dOhEWFsaVV17Jzp07Tc30//7f/8MwDB544AFT9n/w4EFuvvlmunTpgq+vL0OGDGHz5s1tmqGqqoo5c+bQu3dvfH196du3L3/84x9p7Z4269atY9KkSURGRmIYBitWrKh1v8PhYO7cuXTt2hVfX1+SkpLYvXt3m+aoqKjgt7/9LUOGDMHf35/IyEhuvfVWDh061KY5furuu+/GMAyefvppU3JkZmZyxRVXEBgYiL+/PyNHjmTfvn1tmqOoqIgZM2YQFRWFr68vsbGxLFq0qEUzQNPet0pLS5k+fTpdunTBZrNxzTXXkJOT0+JZxPXoc60ufa7pc60pOX5Kn2sd53NNhZhJPv/8c6ZPn86GDRv4+OOPqaio4JJLLqG4uNiUPJs2beKFF15g6NChpuz/+PHjnH/++Xh6evLBBx+wfft2nnzySTp37tymOf7yl7/wj3/8g+eff57MzEz+8pe/8Ne//pXnnnuuVfdbXFzMsGHDWLhwYb33//Wvf+XZZ59l0aJFbNy4EX9/fyZMmEBpaWmb5SgpKSEtLY05c+aQlpbGf//7X3bu3MkVV1zRohnOlON0y5cvZ8OGDURGRrZ4hqbk2LNnDz/72c8YOHAgn332Gd9++y1z5szBx8enTXPMnDmT1atX8+9//5vMzEweeOABZsyYwcqVK1s0R1Pet/7v//6P//3vf7z99tt8/vnnHDp0iKuvvrpFc4hr0udabfpc0+daU3OcTp9r1TrM55pDXEJubq4DcHz++edtvu+TJ086oqOjHR9//LHjggsucNx///1tnuG3v/2t42c/+1mb7/enJk6c6Ljttttqrbv66qsdN910U5tlABzLly933rbb7Y6IiAjH448/7lx34sQJh7e3t+ONN95osxz1SUlJcQCO7OzsNs9x4MABR7du3RwZGRmOnj17Ov72t7+1WoaGclx//fWOm2++uVX325QcgwYNcjz22GO11g0fPtzx+9//vlWz/PR968SJEw5PT0/H22+/7RyTmZnpABzr169v1SzievS5ps+1Gvpca1oOfa79qKN8rumImIsoKCgAIDg4uM33PX36dCZOnEhSUlKb77vGypUrSUhI4LrrriMsLIz4+HhefPHFNs8xZswY1qxZw65duwD45ptv+PLLL0lOTm7zLDWysrI4cuRIrdcnMDCQxMRE1q9fb1ouqP69NQyDoKCgNt2v3W7nlltu4eGHH2bQoEFtuu/TM7z33nv079+fCRMmEBYWRmJiYqPTTVrLmDFjWLlyJQcPHsThcPDpp5+ya9cuLrnkklbd70/ft1JTU6moqKj1uzpw4EB69Ohh+u+qtD19rulzrSH6XKtLn2u1dZTPNRViLsBut/PAAw9w/vnnM3jw4Dbd95tvvklaWhoLFixo0/3+1Pfff88//vEPoqOj+fDDD7nnnnu47777ePXVV9s0x6xZs/jlL3/JwIED8fT0JD4+ngceeICbbrqpTXOc7siRIwCEh4fXWh8eHu68zwylpaX89re/5YYbbiAgIKBN9/2Xv/wFDw8P7rvvvjbd7+lyc3MpKiri//2//8ell17KRx99xFVXXcXVV1/N559/3qZZnnvuOWJjY4mKisLLy4tLL72UhQsXMm7cuFbbZ33vW0eOHMHLy6vOHzBm/65K29Pnmj7XGqPPtbr0uVZbR/lc8zjnLcg5mz59OhkZGXz55Zdtut/9+/dz//338/HHH7f43N/mstvtJCQkMH/+fADi4+PJyMhg0aJFTJkypc1yvPXWWyxdupTXX3+dQYMGkZ6ezgMPPEBkZGSb5nB1FRUV/OIXv8DhcPCPf/yjTfedmprKM888Q1paGoZhtOm+T2e32wGYPHky//d//wdAXFwcX3/9NYsWLeKCCy5osyzPPfccGzZsYOXKlfTs2ZN169Yxffp0IiMjW+2IgFnvW+Ie9LmmzzV3o881fa6Z8b6lI2ImmzFjBqtWreLTTz8lKiqqTfedmppKbm4uw4cPx8PDAw8PDz7//HOeffZZPDw8qKqqarMsXbt2JTY2tta6mJiYFu/ScyYPP/yw89vDIUOGcMstt/B///d/pn6zGhERAVCnQ09OTo7zvrZU82GVnZ3Nxx9/3ObfGn7xxRfk5ubSo0cP5+9tdnY2Dz74IL169WqzHCEhIXh4eJj+e3vq/7d391E93v8fwJ8tpU83uqM7uvkkUhYSJ8VyOzdnp2kzfVhL1NkcuanNYgdZm9uFsNGxUGGs5TjplFFs1XFa7g4fLC2JrXZEY1pYpI/39w+/rp/Puk+uOJ6Pcz7nuO7e1+t6u/o8va+u61JTgyVLliAuLg7+/v4YMGAA5s2bB5VKhfXr1z+XfTb1vWVjY4Pa2lpUVVVprd9Z5yp1DubaE8y1pjHXtDHXtL1KucaBWCcRQmDevHlIS0vDzz//DKVSKXsNY8eOxcWLF6FWq6XPkCFDEBQUBLVaDV1dXdlqGT58eIPXhV6+fBmOjo6y1QA8eYPSa69p/1jo6upKV4k6g1KphI2NDX766SdpXnV1NU6ePAkfHx9Za6kPq5KSEhw7dgyWlpay7h8AgoODceHCBa3z1s7ODlFRUcjKypKtDn19fQwdOrTTz9tHjx7h0aNHspy3LX1veXl5QU9PT+tcLS4uRllZmeznKsmPuaaNudY05po25pq2VynXeGtiJ5k7dy727duH9PR0mJiYSPeZmpqaQqFQyFKDiYlJg3v3jYyMYGlpKfs9/R9//DF8fX2xevVqBAYG4tSpU0hISEBCQoKsdfj7+2PVqlVwcHBA//79ce7cOcTFxSE0NPS57vfevXu4cuWKNH3t2jWo1WpYWFjAwcEBkZGRWLlyJfr06QOlUono6GjY2dkhICBAtjpsbW3x3nvv4ezZs8jMzIRGo5HOWwsLC+jr68tSh4ODQ4Og1NPTg42NDVxdXTushtbUERUVBZVKBT8/P4wePRpHjhxBRkYGcnNzZa1j5MiRiIqKgkKhgKOjI/Ly8rB7927ExcV1aB0tfW+ZmpoiLCwMn3zyCSwsLNCtWzfMnz8fPj4+GDZsWIfWQi8e5po25hpzrbV1MNde4Vx75vcuUrsAaPSTlJTUqXV11mt+hRAiIyNDvP7666Jr166iX79+IiEhQfYaqqurRUREhHBwcBAGBgbC2dlZLF26VDx8+PC57jcnJ6fR8yEkJEQI8eRVv9HR0cLa2lp07dpVjB07VhQXF8tax7Vr15o8b3NycmSrozHP6zW/ralj586dwsXFRRgYGIiBAweKgwcPyl5HRUWFmDlzprCzsxMGBgbC1dVVbNiwQTx+/LhD62jN91ZNTY0IDw8X5ubmwtDQULzzzjuioqKiQ+ugFxNzrSHmGnOtNXU0hrn2auSazv8VQURERERERDLhM2JEREREREQy40CMiIiIiIhIZhyIERERERERyYwDMSIiIiIiIplxIEZERERERCQzDsSIiIiIiIhkxoEYERERERGRzDgQo5dKcnIyzMzMOruMl46TkxM2bdrUKfseNWoUIiMj27RNTEwMBg0aJE3PnDkTAQEBHVrX89CZ/UxELyfmWvsw1+TBXHu+OBCjl4pKpcLly5c7u4xWy83NhY6ODszNzfHgwQOtZadPn4aOjg50dHQarF//sba2xpQpU3D16lVpnfPnz+Ptt9+GlZUVDAwM4OTkBJVKhcrKStmOS26bN29GcnJyZ5fRotOnT+Ojjz7q7DKI6CXCXGOuvciYa88XB2L0UlEoFLCysursMtrMxMQEaWlpWvN27twJBweHRtcvLi7G9evXsX//fhQWFsLf3x8ajQZ//fUXxo4dCwsLC2RlZaGoqAhJSUmws7PD/fv35TiUTmFqavpSXDHu0aMHDA0NO7sMInqJMNeYay8y5trzxYEYtcuoUaMwf/58REZGwtzcHNbW1ti+fTvu37+PWbNmwcTEBC4uLjh8+LC0jUajQVhYGJRKJRQKBVxdXbF582Zp+YMHD9C/f3+tKy+lpaUwMTFBYmIigIa3cNT/qj8xMREODg4wNjZGeHg4NBoNYmNjYWNjAysrK6xatUra5vfff4eOjg7UarU0r6qqCjo6OsjNzQXw/1fwsrKy4OnpCYVCgTFjxqCyshKHDx+Gm5sbunXrhvfffx///vtvi/0VEhIiHQMA1NTUICUlBSEhIY2ub2VlBVtbW/j5+WH58uW4dOkSrly5gvz8fPzzzz/YsWMHPD09oVQqMXr0aGzcuBFKpbLZGu7evYvp06fDyMgIPXv2xNatW7WWl5WVYfLkyTA2Nka3bt0QGBiImzdvNujrPXv2wMnJCaamppg2bRru3r0rrXP//n3MmDEDxsbGsLW1xYYNG1rsGwBYu3YtrK2tYWJigrCwsAZXWf97C0d7zj8A+PXXXzFp0iQYGxvD2toawcHBuHXrlla7CxYswKJFi2BhYQEbGxvExMRIy4UQiImJgYODA7p27Qo7OzssWLBAWv7fWzg6ok+JSB7MNeYac425JjcOxKjddu3ahe7du+PUqVOYP38+5syZg6lTp8LX1xdnz57F+PHjERwcLH2hP378GL169cL+/ftx6dIlLF++HEuWLEFqaioAwMDAAHv37sWuXbuQnp4OjUaDDz74AG+++SZCQ0ObrKO0tBSHDx/GkSNH8P3332Pnzp1466238OeffyIvLw9fffUVli1bhpMnT7b5GGNiYrBlyxb88ssvKC8vR2BgIDZt2oR9+/bh0KFDyM7OxjfffNNiO8HBwTh+/DjKysoAAAcOHICTkxMGDx7c4rYKhQIAUFtbCxsbG9TV1SEtLQ1CiDYdy7p16zBw4ECcO3cOn332GSIiInD06FEAT/5uJk+ejL///ht5eXk4evQorl69CpVKpdVGaWkpDh48iMzMTGRmZiIvLw9r166VlkdFRSEvLw/p6enIzs5Gbm4uzp4922xdqampiImJwerVq3HmzBnY2toiPj6+xeNp6/lXVVWFMWPGwNPTE2fOnMGRI0dw8+ZNBAYGNmjXyMgIJ0+eRGxsLL788kupnw4cOICNGzfi22+/RUlJCQ4ePAgPD49G6+uoPiUi+TDXmGvMNeaarARRO4wcOVKMGDFCmq6rqxNGRkYiODhYmldRUSEAiIKCgibbmTt3rpgyZYrWvNjYWNG9e3cxb948YWtrK27duiUtS0pKEqamptL0559/LgwNDUV1dbU0b8KECcLJyUloNBppnqurq1izZo0QQohr164JAOLcuXPS8jt37ggAIicnRwghRE5OjgAgjh07Jq2zZs0aAUCUlpZK82bPni0mTJjQ5PHVt3Pnzh0REBAgvvjiCyGEEKNHjxabN28WaWlp4ukfw6fXF0KI69evC19fX9GzZ0/x8OFDIYQQS5YsEV26dBEWFhZi4sSJIjY2Vty4caPJGoQQwtHRUUycOFFrnkqlEpMmTRJCCJGdnS10dXVFWVmZtLywsFAAEKdOnRJCNN7XUVFRwtvbWwghxN27d4W+vr5ITU2Vlt++fVsoFAoRERHRZG0+Pj4iPDxca563t7cYOHCgNB0SEiImT54sTbfn/FuxYoUYP3681n7Ky8sFAFFcXNxou0IIMXToULF48WIhhBAbNmwQffv2FbW1tY0ei6Ojo9i4caMQomP6lIjkw1x7grnGXHsac+354m/EqN0GDBgg/VlXVxeWlpZaV1Gsra0BQOth261bt8LLyws9evSAsbExEhISpKtp9RYuXIi+fftiy5YtSExMhKWlZbN1ODk5wcTERGu/7u7ueO2117Tmteeh36eP0draGoaGhnB2dm5Xu6GhoUhOTsbVq1dRUFCAoKCgJtft1asXjIyMpHvkDxw4AH19fQDAqlWrcOPGDWzbtg39+/fHtm3b0K9fP1y8eLHZ/fv4+DSYLioqAgAUFRXB3t4e9vb20nJ3d3eYmZlJ6wAN+9rW1lY6/tLSUtTW1sLb21tabmFhAVdX12brKioq0tqmsVob09bz7/z588jJyYGxsbH06devn1R7Y+3+9xinTp2KmpoaODs748MPP0RaWhrq6uqaPK5n7VMikhdzjbnGXGOuyYkDMWo3PT09rWkdHR2tefVvTXr8+DEAICUlBZ9++inCwsKQnZ0NtVqNWbNmoba2VqudyspKXL58Gbq6uigpKXnmOurn1ddRH2TiqVsgHj161GLbLbXbkkmTJqGmpgZhYWHw9/dvNoiPHz+OCxcuoLq6Gmq1usEXuqWlJaZOnYr169ejqKgIdnZ2WL9+favqeBbPcvxy1NLc+Xfv3j34+/tDrVZrfUpKSuDn59dsu/Vt2Nvbo7i4GPHx8VAoFAgPD4efn1+T5097j6Oz+pToVcdcY64x15hrcuJAjGSTn58PX19fhIeHw9PTEy4uLlpXbOqFhobCw8MDu3btwuLFi7WusnSEHj16AAAqKiqkeU8/4Py8dOnSBTNmzEBubm6zzwYAgFKpRO/evbWuKDVFX18fvXv3bvHtUidOnGgw7ebmBgBwc3NDeXk5ysvLpeWXLl1CVVUV3N3dW6wBAHr37g09PT2tZxbu3LnT4muZ3dzcGjzn8N9aO8LgwYNRWFgIJycnuLi4aH2MjIxa3Y5CoYC/vz++/vpr5ObmoqCgoNGrth3Rp0T0YmOuMdcaw1yj1urS2QXQq6NPnz7YvXs3srKyoFQqsWfPHpw+fVrrrUhbt25FQUEBLly4AHt7exw6dAhBQUE4ceKEdAvDs1IoFBg2bBjWrl0LpVKJyspKLFu2rEPabsmKFSsQFRXV4m0pTcnMzERKSgqmTZuGvn37QgiBjIwM/Pjjj0hKSmp22/z8fMTGxiIgIABHjx7F/v37cejQIQDAuHHj4OHhgaCgIGzatAl1dXUIDw/HyJEjMWTIkFbVZmxsjLCwMOn4rKyssHTpUq1baRoTERGBmTNnYsiQIRg+fDj27t2LwsJCrVtlOsLcuXOxfft2TJ8+XXp71JUrV5CSkoIdO3ZAV1e3xTaSk5Oh0Wjg7e0NQ0NDfPfdd1AoFHB0dGywbkf0KRG92JhrzLXGMNeotfgbMZLN7Nmz8e6770KlUsHb2xu3b99GeHi4tPy3335DVFQU4uPjpfuP4+PjcevWLURHR3doLYmJiairq4OXlxciIyOxcuXKDm2/Kfr6+ujevbvWf3bZFu7u7jA0NMTChQsxaNAgDBs2DKmpqdixYweCg4Ob3XbhwoU4c+YMPD09sXLlSsTFxWHChAkAntw2kJ6eDnNzc/j5+WHcuHFwdnbGDz/80Kb61q1bhzfeeAP+/v4YN24cRowYAS8vr2a3UalUiI6OxqJFi+Dl5YU//vgDc+bMadN+W8POzg75+fnQaDQYP348PDw8EBkZCTMzsxZDtZ6ZmRm2b9+O4cOHY8CAATh27BgyMjIa/QdIR/UpEb24mGvMtcYw16i1dIRo47tCiYiIiIiI6JnwN2JEREREREQy40CMiIiIiIhIZhyIERERERERyYwDMSIiIiIiIplxIEZERERERCQzDsSIiIiIiIhkxoEYERERERGRzDgQIyIiIiIikhkHYkRERERERDLjQIyIiIiIiEhmHIgRERERERHJjAMxIiIiIiIimf0PImfsS0bss0UAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -380,14 +372,6 @@ "lucj_mps_energy = np.zeros((2, len(chi_max_list)))\n", "\n", "# Construct Hartree-Fock state\n", - "dim = ffsim.dim(norb, nelec)\n", - "strings_a, strings_b = ffsim.addresses_to_strings(\n", - " range(dim),\n", - " norb=norb,\n", - " nelec=nelec,\n", - " bitstring_type=ffsim.BitstringType.STRING,\n", - " concatenate=False,\n", - ")\n", "initial_mps = bitstring_to_mps(((1 << n_alpha) - 1, (1 << n_beta) - 1), norb)\n", "\n", "# Loop over cutoff and bond dimension\n", @@ -396,7 +380,7 @@ " final_mps = deepcopy(initial_mps)\n", " options = {\"trunc_params\": {\"chi_max\": int(chi_max), \"svd_min\": svd_min}}\n", " eng = TEBDEngine(final_mps, None, options)\n", - " apply_ucj_op_spin_balanced(eng, lucj_operator)\n", + " apply_ucj_op_spin_balanced(eng, lucj_op)\n", " lucj_mps_energy[i, j] = hamiltonian_mpo.expectation_value_finite(final_mps)\n", "\n", "fig = plt.figure(figsize=(10, 4))\n", diff --git a/python/ffsim/tenpy/gates/abstract_gates.py b/python/ffsim/tenpy/gates/abstract_gates.py index 5eba1b5d7..e8afdbb1c 100644 --- a/python/ffsim/tenpy/gates/abstract_gates.py +++ b/python/ffsim/tenpy/gates/abstract_gates.py @@ -8,6 +8,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy abstract gates.""" import numpy as np import tenpy.linalg.np_conserved as npc @@ -27,15 +28,13 @@ def apply_single_site(eng: TEBDEngine, U1: np.ndarray, site: int) -> None: r"""Apply a single-site gate to an MPS. Args: - eng: The TEBD Engine. + eng: The TEBD engine. U1: The single-site quantum gate. site: The gate will be applied to `site` on the MPS. Returns: None """ - - # apply single-site gate U1_npc = npc.Array.from_ndarray(U1, [shfs.leg, shfs.leg.conj()], labels=["p", "p*"]) psi = eng.get_resume_data()["psi"] psi.apply_local_op(site, U1_npc) @@ -51,10 +50,14 @@ def apply_two_site( r"""Apply a two-site gate to an MPS. Args: - eng: The TEBD Engine. + eng: The TEBD engine. U2: The two-site quantum gate. sites: The gate will be applied to adjacent sites `(site1, site2)` on the MPS. - norm_tol: The norm error above which we recanonicalize the MPS. + norm_tol: The norm error above which we recanonicalize the MPS. In general, the + application of a two-site gate to an MPS with truncation may degrade its + canonical form. To mitigate this, we explicitly bring the MPS back into + canonical form, if the Frobenius norm of the `site-resolved norm errors array `_ + is greater than `norm_tol`. Returns: None diff --git a/python/ffsim/tenpy/gates/basic_gates.py b/python/ffsim/tenpy/gates/basic_gates.py index ca52a5e70..37c85b922 100644 --- a/python/ffsim/tenpy/gates/basic_gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy basic gates.""" + import cmath import math @@ -30,15 +32,16 @@ def _sym_cons_basis(gate: np.ndarray) -> np.ndarray: """ # convert to (N, Sz)-symmetry-conserved basis - if gate.shape == (4, 4): # 1-site gate + if gate.shape == (4, 4): # single-site gate # swap = [1, 3, 0, 2] perm = [2, 0, 3, 1] - elif gate.shape == (16, 16): # 2-site gate + elif gate.shape == (16, 16): # two-site gate # swap = [5, 11, 2, 7, 12, 15, 9, 14, 1, 6, 0, 3, 8, 13, 4, 10] perm = [10, 8, 2, 11, 14, 0, 9, 3, 12, 6, 15, 1, 4, 13, 7, 5] else: raise ValueError( - "only 1-site and 2-site gates implemented for symmetry basis conversion" + "only single-site and two-site gates implemented for symmetry basis " + "conversion" ) return gate[perm][:, perm] @@ -49,8 +52,7 @@ def givens_rotation( ) -> np.ndarray: r"""The Givens rotation gate. - The Givens rotation gate as defined in - `apply_givens_rotation `__, + The Givens rotation gate defined in :func:`~ffsim.apply_givens_rotation`, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -67,6 +69,10 @@ def givens_rotation( The Givens rotation gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ + # define parameters + c = math.cos(theta) + s = -cmath.exp(-1j * phi) * math.sin(theta) + # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators @@ -77,11 +83,9 @@ def givens_rotation( # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) # ) - Ggate_a = np.eye(16, dtype=complex) - c = math.cos(theta) - for i in [1, 3, 4, 6, 9, 11, 12, 14]: - Ggate_a[i, i] = c - s = -cmath.exp(-1j * phi) * math.sin(theta) + Ggate_a = np.diag( + np.array([1, c, 1, c, c, 1, c, 1, 1, c, 1, c, c, 1, c, 1], dtype=complex) + ) Ggate_a[1, 4] = -s Ggate_a[3, 6] = -s Ggate_a[9, 12] = s @@ -101,11 +105,9 @@ def givens_rotation( # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) # ) - Ggate_b = np.eye(16, dtype=complex) - c = math.cos(theta) - for i in [2, 3, 6, 7, 8, 9, 12, 13]: - Ggate_b[i, i] = c - s = -cmath.exp(-1j * phi) * math.sin(theta) + Ggate_b = np.diag( + np.array([1, 1, c, c, 1, 1, c, c, c, c, 1, 1, c, c, 1, 1], dtype=complex) + ) Ggate_b[2, 8] = -s Ggate_b[3, 9] = s Ggate_b[6, 12] = -s @@ -134,8 +136,7 @@ def givens_rotation( def num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarray: r"""The number interaction gate. - The number interaction gate as defined in - `apply_num_interaction `__, + The number interaction gate defined in :func:`~ffsim.apply_num_interaction`, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -151,21 +152,20 @@ def num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarra The number interaction gate in the TeNPy (N, Sz)-symmetry-conserved basis. """ + # define parameters + e = cmath.exp(1j * theta) + # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ngate_a = sp.linalg.expm(1j * theta * Nu) - Ngate_a = np.eye(4, dtype=complex) - for i in [1, 3]: - Ngate_a[i, i] = cmath.exp(1j * theta) + Ngate_a = np.diag([1, e, 1, e]) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # Ngate_b = sp.linalg.expm(1j * theta * Nd) - Ngate_b = np.eye(4, dtype=complex) - for i in [2, 3]: - Ngate_b[i, i] = cmath.exp(1j * theta) + Ngate_b = np.diag([1, 1, e, e]) # define total gate if spin is Spin.ALPHA: @@ -186,8 +186,7 @@ def num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarra def on_site_interaction(theta: float) -> np.ndarray: r"""The on-site interaction gate. - The on-site interaction gate as defined in - `apply_on_site_interaction `__, + The on-site interaction gate defined in :func:`~ffsim.apply_on_site_interaction`, returned in the TeNPy (N, Sz)-symmetry-conserved basis. Args: @@ -199,8 +198,8 @@ def on_site_interaction(theta: float) -> np.ndarray: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # OSgate = sp.linalg.expm(1j * theta * Nu @ Nd) - OSgate = np.eye(4, dtype=complex) - OSgate[3, 3] = cmath.exp(1j * theta) + e = cmath.exp(1j * theta) + OSgate = np.diag([1, 1, 1, e]) # convert to (N, Sz)-symmetry-conserved basis OSgate_sym = _sym_cons_basis(OSgate) @@ -211,9 +210,9 @@ def on_site_interaction(theta: float) -> np.ndarray: def num_num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.ndarray: r"""The number-number interaction gate. - The number-number interaction gate as defined in - `apply_num_num_interaction `__, - returned in the TeNPy (N, Sz)-symmetry-conserved basis. + The number-number interaction gate defined in + :func:`~ffsim.apply_num_num_interaction`, returned in the TeNPy + (N, Sz)-symmetry-conserved basis. Args: theta: The rotation angle. @@ -229,21 +228,20 @@ def num_num_interaction(theta: float, spin: Spin = Spin.ALPHA_AND_BETA) -> np.nd basis. """ + # define parameters + e = cmath.exp(1j * theta) + # alpha sector / up spins if spin in [Spin.ALPHA, Spin.ALPHA_AND_BETA]: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # NNgate_a = sp.linalg.expm(1j * theta * np.kron(Nu, Nu)) - NNgate_a = np.eye(16, dtype=complex) - for i in [5, 7, 13, 15]: - NNgate_a[i, i] = cmath.exp(1j * theta) + NNgate_a = np.diag([1, 1, 1, 1, 1, e, 1, e, 1, 1, 1, 1, 1, e, 1, e]) # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: # # using TeNPy SpinHalfFermionSite(cons_N=None, cons_Sz=None) operators # NNgate_b = sp.linalg.expm(1j * theta * np.kron(Nd, Nd)) - NNgate_b = np.eye(16, dtype=complex) - for i in [10, 11, 14, 15]: - NNgate_b[i, i] = cmath.exp(1j * theta) + NNgate_b = np.diag([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, e, e, 1, 1, e, e]) # define total gate if spin is Spin.ALPHA: diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py index 27dacc3f0..e64084fb6 100644 --- a/python/ffsim/tenpy/gates/diag_coulomb.py +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy diagonal Coulomb evolution gate.""" + import itertools import numpy as np @@ -26,12 +28,16 @@ def apply_diag_coulomb_evolution( r"""Apply a diagonal Coulomb evolution gate to an MPS. The diagonal Coulomb evolution gate is defined in - `apply_diag_coulomb_evolution `__. + :func:`~ffsim.apply_diag_coulomb_evolution`. Args: - eng: The TEBD Engine. + eng: The TEBD engine. mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. - norm_tol: The norm error above which we recanonicalize the MPS. + norm_tol: The norm error above which we recanonicalize the MPS. In general, the + application of a two-site gate to an MPS with truncation may degrade its + canonical form. To mitigate this, we explicitly bring the MPS back into + canonical form, if the Frobenius norm of the `site-resolved norm errors array `_ + is greater than `norm_tol`. Returns: None @@ -44,8 +50,8 @@ def apply_diag_coulomb_evolution( mat_aa, mat_ab = mat # apply alpha-alpha gates - for i, j in itertools.product(range(norb), repeat=2): - if j > i and mat_aa[i, j]: + for i, j in itertools.combinations(range(norb), 2): + if mat_aa[i, j]: apply_two_site( eng, num_num_interaction(-mat_aa[i, j]), diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py index 7f4823527..eece2c125 100644 --- a/python/ffsim/tenpy/gates/orbital_rotation.py +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy orbital rotation gate.""" + import cmath import math @@ -27,13 +29,16 @@ def apply_orbital_rotation( ) -> None: r"""Apply an orbital rotation gate to an MPS. - The orbital rotation gate is defined in - `apply_orbital_rotation `__. + The orbital rotation gate is defined in :func:`~ffsim.apply_orbital_rotation`. Args: - eng: The TEBD Engine. + eng: The TEBD engine. mat: The orbital rotation matrix of dimension `(norb, norb)`. - norm_tol: The norm error above which we recanonicalize the MPS. + norm_tol: The norm error above which we recanonicalize the MPS. In general, the + application of a two-site gate to an MPS with truncation may degrade its + canonical form. To mitigate this, we explicitly bring the MPS back into + canonical form, if the Frobenius norm of the `site-resolved norm errors array `_ + is greater than `norm_tol`. Returns: None diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index a394450a6..a2f640a5f 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy unitary cluster Jastrow gate.""" + from __future__ import annotations import numpy as np @@ -26,10 +28,17 @@ def apply_ucj_op_spin_balanced( ) -> None: r"""Apply a spin-balanced unitary cluster Jastrow gate to an MPS. + The spin-balanced unitary cluster Jastrow gate is defined in + :class:`~ffsim.variational.ucj_spin_balanced.UCJOpSpinBalanced`. + Args: eng: The TEBD engine. ucj_op: The spin-balanced unitary cluster Jastrow operator. - norm_tol: The norm error above which we recanonicalize the MPS. + norm_tol: The norm error above which we recanonicalize the MPS. In general, the + application of a two-site gate to an MPS with truncation may degrade its + canonical form. To mitigate this, we explicitly bring the MPS back into + canonical form, if the Frobenius norm of the `site-resolved norm errors array `_ + is greater than `norm_tol`. Returns: None diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 63a962255..33625317c 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy molecular Hamiltonian.""" + from __future__ import annotations import itertools @@ -26,39 +28,32 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" - def init_sites(self, params): - cons_N = params.get("cons_N", "N", expect_type=str) - cons_Sz = params.get("cons_Sz", "Sz", expect_type=str) - site = SpinHalfFermionSite(cons_N=cons_N, cons_Sz=cons_Sz) - return site + def init_sites(self, params) -> SpinHalfFermionSite: + """Initialize sites.""" + return SpinHalfFermionSite() - def init_lattice(self, params): - L = params.get("L", 1, expect_type=int) - norb = params.get("norb", None, expect_type=int) + def init_lattice(self, params) -> Lattice: + """Initialize lattice.""" + one_body_tensor = params.get("one_body_tensor", None, expect_type="array") + norb = one_body_tensor.shape[0] site = self.init_sites(params) - basis = np.array(([norb, 0.0], [0, 1])) + basis = np.array(([norb, 0], [0, 1])) pos = np.array([[i, 0] for i in range(norb)]) lat = Lattice( - [L, 1], + [1, 1], [site] * norb, - order="default", - bc="open", - bc_MPS="finite", basis=basis, positions=pos, ) return lat - def init_terms(self, params): + def init_terms(self, params) -> None: + """Initialize terms.""" dx0 = np.array([0, 0]) - norb = params.get("norb", None, expect_type=int) - one_body_tensor = params.get( - "one_body_tensor", np.zeros((norb, norb)), expect_type="array" - ) - two_body_tensor = params.get( - "two_body_tensor", np.zeros((norb, norb, norb, norb)), expect_type="array" - ) + one_body_tensor = params.get("one_body_tensor", None, expect_type="array") + two_body_tensor = params.get("two_body_tensor", None, expect_type="array") constant = params.get("constant", 0, expect_type="real") + norb = one_body_tensor.shape[0] for p, q in itertools.product(range(norb), repeat=2): h1 = one_body_tensor[q, p] @@ -133,7 +128,6 @@ def from_molecular_hamiltonian( """ model_params = dict( - norb=molecular_hamiltonian.norb, one_body_tensor=molecular_hamiltonian.one_body_tensor, two_body_tensor=molecular_hamiltonian.two_body_tensor, constant=molecular_hamiltonian.constant, diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 75cd181e1..e237cc68a 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -8,6 +8,8 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""TeNPy utility functions.""" + from __future__ import annotations from tenpy.networks.mps import MPS diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index d26d8387e..64f04d6bf 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -51,18 +51,17 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate random Givens rotation parameters @@ -110,18 +109,17 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate random number interaction parameters @@ -161,18 +159,17 @@ def test_on_site_interaction( # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate random on-site interaction parameters @@ -217,18 +214,17 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate random number-number interaction parameters diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py index 00e6597ed..bd4e1098a 100644 --- a/tests/python/tenpy/gates/diag_coulomb_test.py +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -39,18 +39,17 @@ def test_apply_diag_coulomb_evolution( # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate random diagonal Coulomb evolution parameters diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 2c472dee4..f77ad7cde 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -39,18 +39,17 @@ def test_apply_orbital_rotation( # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - original_vec = np.zeros(dim, dtype=complex) - original_vec[idx] = 1 + original_vec = ffsim.linalg.one_hot(dim, idx) # convert random product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - mps = bitstring_to_mps((int(strings_a[idx], 2), int(strings_b[idx], 2)), norb) + mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) # generate a random orbital rotation diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 68d88025c..173d4bc5d 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -44,19 +44,18 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): # generate a random product state dim = ffsim.dim(norb, nelec) idx = rng.integers(0, high=dim) - product_state = np.zeros(dim) - product_state[idx] = 1 + product_state = ffsim.linalg.one_hot(dim, idx) # convert product state to MPS strings_a, strings_b = ffsim.addresses_to_strings( - range(dim), + [idx], norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) product_state_mps = bitstring_to_mps( - (int(strings_a[idx], 2), int(strings_b[idx], 2)), norb + (int(strings_a[0], 2), int(strings_b[0], 2)), norb ) # test expectation is preserved From 697bbc78398b5b8395525c6d0b70f98f5c8e9ddf Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 22 Nov 2024 12:14:53 +0100 Subject: [PATCH 63/88] add time argument to apply_diag_coulomb_evolution function --- python/ffsim/tenpy/gates/diag_coulomb.py | 6 ++++-- python/ffsim/tenpy/gates/ucj.py | 2 +- tests/python/tenpy/gates/basic_gates_test.py | 12 ++++-------- tests/python/tenpy/gates/diag_coulomb_test.py | 13 +++++-------- tests/python/tenpy/gates/orbital_rotation_test.py | 3 +-- 5 files changed, 15 insertions(+), 21 deletions(-) diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py index e64084fb6..5c7201356 100644 --- a/python/ffsim/tenpy/gates/diag_coulomb.py +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -22,6 +22,7 @@ def apply_diag_coulomb_evolution( eng: TEBDEngine, mat: np.ndarray, + time: float, *, norm_tol: float = 1e-5, ) -> None: @@ -33,6 +34,7 @@ def apply_diag_coulomb_evolution( Args: eng: The TEBD engine. mat: The diagonal Coulomb matrices of dimension `(2, norb, norb)`. + time: The evolution time. norm_tol: The norm error above which we recanonicalize the MPS. In general, the application of a two-site gate to an MPS with truncation may degrade its canonical form. To mitigate this, we explicitly bring the MPS back into @@ -54,11 +56,11 @@ def apply_diag_coulomb_evolution( if mat_aa[i, j]: apply_two_site( eng, - num_num_interaction(-mat_aa[i, j]), + num_num_interaction(-time * mat_aa[i, j]), (i, j), norm_tol=norm_tol, ) # apply alpha-beta gates for i in range(norb): - apply_single_site(eng, on_site_interaction(-mat_ab[i, i]), i) + apply_single_site(eng, on_site_interaction(-time * mat_ab[i, i]), i) diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index a2f640a5f..070e91df0 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -55,7 +55,7 @@ def apply_ucj_op_spin_balanced( orb_rot.conjugate().T @ current_basis, norm_tol=norm_tol, ) - apply_diag_coulomb_evolution(eng, diag_mats, norm_tol=norm_tol) + apply_diag_coulomb_evolution(eng, diag_mats, 1, norm_tol=norm_tol) current_basis = orb_rot if ucj_op.final_orbital_rotation is None: apply_orbital_rotation( diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index 64f04d6bf..50d478c91 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -75,8 +75,7 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): ) # apply random orbital rotation to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) + eng = TEBDEngine(mps, None, {}) ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p, p + 1)) # test expectation is preserved @@ -130,8 +129,7 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): vec = ffsim.apply_num_interaction(original_vec, theta, p, norb, nelec, spin) # apply random number interaction to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) + eng = TEBDEngine(mps, None, {}) ffsim.tenpy.apply_single_site(eng, num_interaction(theta, spin), p) # test expectation is preserved @@ -180,8 +178,7 @@ def test_on_site_interaction( vec = ffsim.apply_on_site_interaction(original_vec, theta, p, norb, nelec) # apply random on-site interaction to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) + eng = TEBDEngine(mps, None, {}) ffsim.tenpy.apply_single_site(eng, on_site_interaction(theta), p) # test expectation is preserved @@ -237,8 +234,7 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): ) # apply random number-number interaction to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) + eng = TEBDEngine(mps, None, {}) ffsim.tenpy.apply_two_site(eng, num_num_interaction(theta, spin), (p, p + 1)) # test expectation is preserved diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py index bd4e1098a..64d7ffc3f 100644 --- a/tests/python/tenpy/gates/diag_coulomb_test.py +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -29,10 +29,7 @@ (4, (0, 0)), ], ) -def test_apply_diag_coulomb_evolution( - norb: int, - nelec: tuple[int, int], -): +def test_apply_diag_coulomb_evolution(norb: int, nelec: tuple[int, int]): """Test applying a diagonal Coulomb evolution gate to an MPS.""" rng = np.random.default_rng() @@ -57,16 +54,16 @@ def test_apply_diag_coulomb_evolution( mat_aa += mat_aa.T mat_ab = np.diag(rng.standard_normal(norb)) diag_coulomb_mats = np.array([mat_aa, mat_ab, mat_aa]) + time = rng.random() # apply random diagonal Coulomb evolution to state vector vec = ffsim.apply_diag_coulomb_evolution( - original_vec, diag_coulomb_mats, 1, norb, nelec + original_vec, diag_coulomb_mats, time, norb, nelec ) # apply random diagonal Coulomb evolution to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) - ffsim.tenpy.apply_diag_coulomb_evolution(eng, diag_coulomb_mats[:2]) + eng = TEBDEngine(mps, None, {}) + ffsim.tenpy.apply_diag_coulomb_evolution(eng, diag_coulomb_mats[:2], time) # test expectation is preserved original_expectation = np.vdot(original_vec, vec) diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index f77ad7cde..4829dff3f 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -59,8 +59,7 @@ def test_apply_orbital_rotation( vec = ffsim.apply_orbital_rotation(original_vec, mat, norb, nelec) # apply random orbital rotation to MPS - options = {"trunc_params": {"chi_max": 16, "svd_min": 1e-6}} - eng = TEBDEngine(mps, None, options) + eng = TEBDEngine(mps, None, {}) ffsim.tenpy.apply_orbital_rotation(eng, mat) # test expectation is preserved From 1f7c322369cb8b702a030c25b078b41e1be71ae3 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 22 Nov 2024 15:09:32 +0100 Subject: [PATCH 64/88] add random molecular Hamiltonian to all gate tests --- docs/how-to-guides/lucj_mps.ipynb | 34 ++++++----- tests/python/tenpy/gates/basic_gates_test.py | 57 +++++++++++++++++-- tests/python/tenpy/gates/diag_coulomb_test.py | 14 ++++- .../tenpy/gates/orbital_rotation_test.py | 14 ++++- 4 files changed, 97 insertions(+), 22 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index d0272a63a..37ed8d95a 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -42,23 +42,29 @@ "output_type": "stream", "text": [ "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmpnxxef5hr\n", - "converged SCF energy = -77.8266321248745\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", - "norb = 4\n", - "nelec = (2, 2)\n" + "Parsing /tmp/tmpn_bkseqz\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Overwritten attributes get_hcore get_ovlp of \n", + "Overwritten attributes get_ovlp get_hcore of \n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute energy_nuc because it is not JSON-serializable\n", " warnings.warn(msg)\n", "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", " warnings.warn(msg)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converged SCF energy = -77.8266321248744\n", + "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" + ] } ], "source": [ @@ -126,17 +132,17 @@ }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374033 E_corr = -0.0475832388658431\n" + " does not have attributes converged\n" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " does not have attributes converged\n" + "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585134\n" ] } ], @@ -307,9 +313,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.78472901487439\n", - "LUCJ energy = -77.84651018653346\n", - "FCI energy = -77.8742165643863\n" + "LUCJ (MPS) energy = -77.77102552350499\n", + "LUCJ energy = -77.84651018653344\n", + "FCI energy = -77.87421656438623\n" ] } ], @@ -351,7 +357,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index 50d478c91..4fc3eab6e 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -24,6 +24,7 @@ num_num_interaction, on_site_interaction, ) +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps @@ -64,6 +65,16 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate random Givens rotation parameters theta = 2 * np.pi * rng.random() phi = 2 * np.pi * rng.random() @@ -76,11 +87,12 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): # apply random orbital rotation to MPS eng = TEBDEngine(mps, None, {}) - ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p, p + 1)) + ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p + 1, p)) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) - mpo_expectation = original_mps.overlap(mps) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) + mpo_expectation = mps.overlap(original_mps) np.testing.assert_allclose(original_expectation, mpo_expectation) @@ -121,6 +133,16 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate random number interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb) @@ -133,7 +155,8 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): ffsim.tenpy.apply_single_site(eng, num_interaction(theta, spin), p) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) @@ -170,6 +193,16 @@ def test_on_site_interaction( mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate random on-site interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb) @@ -182,7 +215,8 @@ def test_on_site_interaction( ffsim.tenpy.apply_single_site(eng, on_site_interaction(theta), p) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) @@ -224,6 +258,16 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate random number-number interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb - 1) @@ -238,6 +282,7 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): ffsim.tenpy.apply_two_site(eng, num_num_interaction(theta, spin), (p, p + 1)) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py index 64d7ffc3f..ee85a684e 100644 --- a/tests/python/tenpy/gates/diag_coulomb_test.py +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -17,6 +17,7 @@ from tenpy.algorithms.tebd import TEBDEngine import ffsim +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps @@ -49,6 +50,16 @@ def test_apply_diag_coulomb_evolution(norb: int, nelec: tuple[int, int]): mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate random diagonal Coulomb evolution parameters mat_aa = np.diag(rng.standard_normal(norb - 1), k=-1) mat_aa += mat_aa.T @@ -66,6 +77,7 @@ def test_apply_diag_coulomb_evolution(norb: int, nelec: tuple[int, int]): ffsim.tenpy.apply_diag_coulomb_evolution(eng, diag_coulomb_mats[:2], time) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 4829dff3f..0d60a127b 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -17,6 +17,7 @@ from tenpy.algorithms.tebd import TEBDEngine import ffsim +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps @@ -52,6 +53,16 @@ def test_apply_orbital_rotation( mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) original_mps = deepcopy(mps) + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random orbital rotation mat = ffsim.random.random_unitary(norb, seed=rng) @@ -63,6 +74,7 @@ def test_apply_orbital_rotation( ffsim.tenpy.apply_orbital_rotation(eng, mat) # test expectation is preserved - original_expectation = np.vdot(original_vec, vec) + original_expectation = np.vdot(original_vec, hamiltonian @ vec) + mol_hamiltonian_mpo.apply_naively(mps) mpo_expectation = mps.overlap(original_mps) np.testing.assert_allclose(original_expectation, mpo_expectation) From 3007015055cbae79fe862334077b8458159ceb8b Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 22 Nov 2024 16:54:59 +0100 Subject: [PATCH 65/88] start simplifying molecular Hamiltonian --- .../hamiltonians/molecular_hamiltonian.py | 116 +++++++++--------- 1 file changed, 58 insertions(+), 58 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 33625317c..cd8598f51 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -55,64 +55,64 @@ def init_terms(self, params) -> None: constant = params.get("constant", 0, expect_type="real") norb = one_body_tensor.shape[0] - for p, q in itertools.product(range(norb), repeat=2): - h1 = one_body_tensor[q, p] - if p == q: - self.add_onsite(h1, p, "Nu") - self.add_onsite(h1, p, "Nd") - self.add_onsite(constant / norb, p, "Id") - else: - self.add_coupling(h1, p, "Cdu", q, "Cu", dx0) - self.add_coupling(h1, p, "Cdd", q, "Cd", dx0) - - for r, s in itertools.product(range(norb), repeat=2): - h2 = two_body_tensor[q, p, s, r] - if p == q == r == s: - self.add_onsite(0.5 * h2, p, "Nu") - self.add_onsite(-0.5 * h2, p, "Nu Nu") - self.add_onsite(0.5 * h2, p, "Nu") - self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") - self.add_onsite(0.5 * h2, p, "Nd") - self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") - self.add_onsite(0.5 * h2, p, "Nd") - self.add_onsite(-0.5 * h2, p, "Nd Nd") - else: - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cd", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cd", dx0, q), - ], - ) + for p in range(norb): + h1 = one_body_tensor[p, p] + self.add_onsite(h1, p, "Ntot") + h2 = two_body_tensor[p, p, p, p] + self.add_onsite(h2, p, "Ntot") + self.add_onsite(-0.5 * h2, p, "Nu Nu") + self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") + self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") + self.add_onsite(-0.5 * h2, p, "Nd Nd") + self.add_onsite(constant / norb, p, "Id") + + for p, q in itertools.combinations(range(norb), 2): + self.add_coupling( + one_body_tensor[q, p], p, "Cdu", q, "Cu", dx0, plus_hc=True + ) + self.add_coupling( + one_body_tensor[q, p], p, "Cdd", q, "Cd", dx0, plus_hc=True + ) + + for p, q, r, s in itertools.product(range(norb), repeat=4): + h2 = two_body_tensor[q, p, s, r] + if not p == q == r == s: + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cu", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdu", dx0, r), + ("Cu", dx0, s), + ("Cd", dx0, q), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, p), + ("Cdd", dx0, r), + ("Cd", dx0, s), + ("Cd", dx0, q), + ], + ) @staticmethod def from_molecular_hamiltonian( From 8f0640c8f454a3ba33bab96099930f99030e7c87 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sat, 23 Nov 2024 11:33:56 +0100 Subject: [PATCH 66/88] simplify two_body_tensor loop in molecular Hamiltonian --- docs/how-to-guides/lucj_mps.ipynb | 34 +++---- .../hamiltonians/molecular_hamiltonian.py | 92 ++++++++++--------- python/ffsim/testing/__init__.py | 2 - python/ffsim/testing/testing.py | 18 ---- tests/python/tenpy/gates/ucj_test.py | 2 +- 5 files changed, 66 insertions(+), 82 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index 37ed8d95a..e0b322c26 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -41,8 +41,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "converged SCF energy = -77.8266321248745\n", - "Parsing /tmp/tmpn_bkseqz\n" + "converged SCF energy = -77.8266321248744\n", + "Parsing /tmp/tmpgbjtc5ah\n", + "converged SCF energy = -77.8266321248744\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "norb = 4\n", + "nelec = (2, 2)\n" ] }, { @@ -55,16 +59,6 @@ "/home/bart/PycharmProjects/ffsim/.ffsim_dev/lib/python3.12/site-packages/pyscf/gto/mole.py:1294: UserWarning: Function mol.dumps drops attribute intor_symmetric because it is not JSON-serializable\n", " warnings.warn(msg)\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643862 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", - "norb = 4\n", - "nelec = (2, 2)\n" - ] } ], "source": [ @@ -132,17 +126,17 @@ }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " does not have attributes converged\n" + "E(CCSD) = -77.87421536374029 E_corr = -0.04758323886585428\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374035 E_corr = -0.04758323886585134\n" + " does not have attributes converged\n" ] } ], @@ -199,7 +193,7 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 54\n" + "maximum MPO bond dimension = 58\n" ] } ], @@ -313,9 +307,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77102552350499\n", + "LUCJ (MPS) energy = -77.77309168986469\n", "LUCJ energy = -77.84651018653344\n", - "FCI energy = -77.87421656438623\n" + "FCI energy = -77.87421656438626\n" ] } ], @@ -357,7 +351,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAF0CAYAAABBv4o9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACWDklEQVR4nOzde1iUdf7/8efMcAYBEQQRT3kERVBR0rbUoszMLMustk3tsLuVlV+rTdstq9+u7nZa23LXtlJrt8wOq5mdLLXsoKIgKZ7SRBQPICpHOc/9+4OYJA6CwtwMvB7XNZfMPZ+55zUNzfCe+3O/PxbDMAxERERERETEaaxmBxAREREREWlrVIiJiIiIiIg4mQoxERERERERJ1MhJiIiIiIi4mQqxERERERERJxMhZiIiIiIiIiTqRATERERERFxMhViIiIiIiIiTqZCTERERERExMnczA7QGtjtdo4cOUK7du2wWCxmxxERcSmGYZCfn094eDhWq74fbAn0uSYicu4a+rmmQqwJHDlyhC5dupgdQ0TEpR06dIiIiAizYwj6XBMRaQpn+1xTIdYE2rVrB1T+x/b39zc5jYiIa8nLy6NLly6O91JpGqtWreLBBx/EbrfzyCOPcOeddzb4vvpcExE5dw39XFMh1gSqpm34+/vrA0tE5BxpClzTKS8vZ+bMmaxbt46AgACGDBnCddddR4cOHRp0f32uiYicv7N9rmkyvoiISCuTmJhI//796dy5M35+fowdO5bVq1ebHUtERM6gQkxERKSFWb9+PePHjyc8PByLxcKKFStqjFmwYAHdu3fHy8uL+Ph4EhMTHbcdOXKEzp07O6537tyZw4cPOyO6iIg0kAoxERGRFqawsJCYmBgWLFhQ6+3Lli1j5syZzJkzh+TkZGJiYhgzZgxZWVlOTioiIudK54iJiFNVVFRQVlZmdgxxIpvNhpubm84Ba4SxY8cyduzYOm9//vnnueuuu5g2bRoACxcu5KOPPmLRokXMmjWL8PDwakfADh8+zLBhw+rcX0lJCSUlJY7reXl5TfAsRESkPirERMRpCgoKyMjIwDAMs6OIk/n4+NCpUyc8PDzMjuLySktLSUpKYvbs2Y5tVquVhIQENmzYAMCwYcNITU3l8OHDBAQE8Mknn/DYY4/Vuc958+bx5JNPNnt2ERH5mQoxEXGKiooKMjIy8PHxISQkREdH2gjDMCgtLeX48eOkpaXRu3dvLdp8nrKzs6moqCA0NLTa9tDQUHbv3g2Am5sbzz33HKNHj8Zut/OHP/yh3o6Js2fPZubMmY7rVa2XRUSk+agQExGnKCsrwzAMQkJC8Pb2NjuOOJG3tzfu7u6kp6dTWlqKl5eX2ZHahGuuuYZrrrmmQWM9PT3x9PRs5kQiInImfS0pIk6lI2Ftk46CNZ3g4GBsNhuZmZnVtmdmZhIWFmZSKhERaSx9MkqLkpnxI6nffkhmxo9mRxERaZE8PDwYMmQIa9ascWyz2+2sWbOG4cOHm5iskt7Hq2sp/z2UQ6Tl0dREk2Vm/Mjx9J2EdIsiNKKn2XFMlfj+fIZse4JQi0GFYSFx4BMMu36G2bFERJyuoKCAffv2Oa6npaWRkpJCUFAQXbt2ZebMmUyZMoW4uDiGDRvG/PnzKSwsdHRRNEvi+/OJ2/bz+/jG3jOInfgQXj5+puZyprLSEvJOHacwN5vDXy4i/vAbhFoM7IaFjaGT8Yu5GpubB1abOzZ3D2zuntjc3LG5eWJzd8fN3QM3Nw/cPDxxc/fA3d0Tm9v5/bnWUj5fW0oOkZbCYqh92XnLy8sjICCA3Nxc/P39G3y/qjck209vSElt+A0pM+NHgl8Zgs3y869jhWEh+66kNl+gthbFxcWkpaXRo0cPnSPUBtX3+p/re2hr9uWXXzJ69Oga26dMmcKSJUsAeOmll3jmmWc4duwYsbGx/OMf/yA+Pr5JHv9cXpPa3serlBju5Ft8KbT6UWRtR4l7O8rc/anw8MfuFYjFKwCbT3tsvkF4+gXh1a49PgEd8AsMwa9dIJZzmNp6Pl90lpeVkp9zgoLcbIryTlCcd4LSghNUFJ7CXnQKS1EO1pJc3Etz8SjPw7s8Hx97Ae2MAnwtxY3OejZ2w0I5NsqxUWZxoxw3KrBRbnGjAjcqLDYqLG5UWNyxWyqv2y1u2C1uWIwKoouTOXNWuN2ArX6XYHfzoeoGgzMGWCyApfptjh2cOe7M16We8RYLlpIChp5ahfWMu1cYFtInfcYFA5rm91akpWjoe6gKsSbQVB9Y5YaVE3dtaZOFR+q3HzLg81trbE/xiif8Ny/TsXMPE1JJU1Ih1rrk5OSQkJBAeXk55eXlPPDAA9x11111jlch5lrO5TWp6338fFUYFvItvhRY/CiytaPY1o4y93aUeQRg9wwE70Cs3gG4+bbHwy8Ir3YdyN72KcP2/9PxRWdil6n49RlJacFJygtOVium3Epz8SzLw6siH5+KfPyMAtpZis4792nDAx9LaY3tRwmhwuKGzSjHRgVVZZWbUY4b5XhYKs77sV1NLr5kunUmz6crZQE9cA/phX9EP0K79ycgKMTseCKN1tD3UE1NNMnx9J2E/uJbQzeLnez03W2yECs+dbTW7bHFmyj69zA2dL6JqElzCGgf7ORkIlKbdu3asX79enx8fCgsLGTAgAFMnDix3hbp0rqFdIuiwrD8YmaDlYM3fYGXjx+nc09QlH+C0oIcKgpPUnH6FMZPxZCtNA/30lw8ywvwtufjay/A3yjAw1KOzWIQSAGBRgGUH4NyoKTuHAC9wXHgxmYxGJ6xGDIWN+yJnHHEpsDwpsDiR6HNj2JbO0rd/Slz98fu1R68ArH4BGLzbY+HbxBe/sH4+HfALzAYv4Ag8jMP4VnLF67Wuz6jUz2f84bdTkVFOeVlpZSVlVJeWkJFWSnl5aVUlJdSXlaGvbyE8rLK6/byMuxn/GtUVP5sVJRhryijIi+L+P0vYT0jh92wsKnzFPDyr3pQoPJ2iwEG9p+2n/F3iuNno9rPlp9+Nn6xvfrPYCnNZ1j28mpHxAyj8sBZAIUElP8AeT9AHnAISK4cc4p2ZLl1Js+3K+WBF+Ae0pOAzv0I7dEf/0C934hrUyFmkro+sIK79TMxlTlKik/TMXk+UDldwmqp/LDaHP5r2mcn0a9sJ8OPvEHuC++zsddvib3+Yby8fc0NLW3OrFmz+Pvf/87111/PW2+9ZXYc09lsNnx8fAAoKSnBMAwt1N3GhUb0JHHgEwze9iRuFjvlhpXkgXMYFjnknPZn2O0UF58mPyebwtxsivNOUlxwkrKCk1SczsEoysFSnIOtJBe3sjw8y/PxLs8nwH6SIPJq7O8woeR6dKTEzf+no2kBGF4BWH+aEunhG4RnuyB8AjrgGxBMu8Bg/Dw8Odez2+r873GWL1stVituVg/c3D1oqrkDie8H18gx3JRzxGJr5Ii+8g6OHdhJTsZuijP3YTv1I76FBwkpPUxHTtKefNqX74bc3ZALpANbKvd3En+y3CPI9+lKefseeIT0IiCiH2E9+uPn377eLDpHX1oCTU1sAud3jtiT2CyV3zxt9R7BoEc+aa6YLdaG1x9leNoCsgkkf/L7nD6ZSXC3foRG9MSw2/l+zdsEbphLd/shAI4RzMGYGQwZf/d5n8AszuPqUxNzc3P5z3/+w3333cfevXvp1auX2ZHqtH79ep555hmSkpI4evQoy5cv59prr60xbsGCBY5zjGJiYnjxxRcZNmxYgx8nJyeHkSNHsnfvXp555hnuvffeOsdqaqJrOZ/XJDPjR7LTdzvex52tpU39N/u/hyvnOF2Qy9G0XeRm7KIkay+2U2n4FR6kY1kGweTUe99sAjnu3pl8325UtO+BZ8feBHTuS1iPKHasXqJz9KVZ6RwxJzrfD6z9ny5geMZrlBpuZN66li69Y5opactzNH0PgYt+hbellM2D5jF0wj21jisvK2Xrh/+i67YXCOUEAAesXcm56I/EjL7xnE7kFudy9UIMoKioCD8/P9577z2uu+46s+PU6ZNPPuHbb79lyJAhTJw4sdZCbNmyZdx2220sXLiQ+Ph45s+fz7vvvsuePXvo2LEjALGxsZSXl9fY/+rVqwkPD3dcz8zMZOLEifzvf/8jNDS01kwqxFyLq78mie/Pr3kkSn9otyoFeac4lraT3MO7Kc3ai9upNNqdPkhI2WE6kFvvfaumRFapMCwcm7qBzj0imzm1tBUqxJzofD+wDLud7U9fwcDizezwiCFq1pdtprDY+vRVDDr9LTs9oomctf6sz7v4dAEp7z9N1I+v4k8hALvc+2O5/En6DbvcGZHlHLWGQiw/P5/w8HD+8Ic/8Nhjj5kdp0EsFkuthVh8fDxDhw7lpZdeAirXoerSpQv33Xcfs2bNavTj3HPPPVx66aXccMMNtd6uQsy1tIbXpKUcARLny8s5QeaByiKtLGsfbjn78S88SMfyI7SvZdoqQKlhI829NzntB2DtPJiO/YbTpXcMVpvNyemlNVCzDhdisVoJnvwSRUsupn/p92xe+S+GXlv3FJ/W4vu1bzPo9LeUGTZ8rpvfoOLTy8ePC3/zFLkn72PDu08x6MhSIst2wMc3sPXLiwi65s906zfYCenFTEdzi0jLLqRHsC+dAryd9rh/+tOfKCgoIDU11SmPN3fuXObOnVvvmJ07d9K1a9dG7be0tJSkpCRmz57t2Ga1WklISGDDhg0N2kdmZiY+Pj60a9eO3Nxc1q9fz913392oHCLNKTSipwqwNso/sAP+sRdD7MU1bkvbuZluyy6v1rzEMMDDUkHf8t1wfDccfw9SKpu1pHv2Ij9oIO5dh9Ap8iI6devTZr4sl+anQqyFCO/Rjw09f8/w/f+gV8o8Tl00kfYhncyO1WyKTxcQ8vXjACR1uokLI+Madf+AoBCG/+5FMjNmsO39xxhy8mMGnf6WiqWXkhh0Fd2u/3/6AG7hDMOgqKzxbZrfT8pgzsodjsYuT17Tn+uHRDRqH97uNixnzktpgKSkJBYuXMi4ceOcVoj9/ve/58Ybb6x3zJlTBBsqOzubioqKGtMIQ0ND2b17d4P2kZ6ezm9/+1tHk4777ruP6OjoRmcREXGmHlFDazRRSYp+jPDYy8nc9R3lGckEnNxOt9J9+FmK6F+6HY5th2NvQmJlF8dDXn0pDB6IV9chRAz4FSHh3c1+WuKiNDWxCTTVFI6y0hIy/jqUHvZ0EgOvYtiMpU2YsmXZ8NqDDD/0KlkE4fvgVnzbBZ7X/tJ3J3Ny5Z8YdPpbAIoNd7aG30zUpMe1BkkL8cupaadLy4l6/DNTsux8agw+Hg3/HsputzNs2DBGjhxJfHw8t956K4WFhbi7uzd4H0eOHOHhhx/mzTffPJfI56y2qYlHjhyhc+fOfPfddwwfPtyx/Q9/+ANfffUVmzZtavIcmproWvSaSGt3tqmr5WWlHNybQvaejRgZSQTl7qBb2f5a13nLIojDPv0oDhmIb49hdB1wEYHBYc54GtJCaWqiC3L38KRk7PPw0fUMy/mYHd9+RP+Lxpkdq8ll7Etl8MHXwQIZ8Y8z+DyLMIBu/QbTrd/H7E78HOPzOUSW7WD40TfI/cf7bOx5J7HX/wEvn3NtQixt3Ysvvkh2djZPPfUUBw8epKysjN27dzfqCFB4eHiji7DmmpoYHByMzWYjMzOz2vbMzEzCwvTHg4i0fmebuurm7sEFUcO4IOrnTrIlxafZu2sLJ/duxHJkKyF5O+lakU5Hy0k6nv4O0r+D9IXwJRy2hHLMN5KysFjaXRBPtwHDa22przb6bZsKsRam39AENm28lvgTK2i35mFKhozG08vH7FhNxrDbOfneA0RYytjmNYRBY6Y06f77DbscI+4yUta9Q+C3f6G7/SAX/vgCmU//l20xMxgy/h61vG8hvN1t7HxqTKPucyy3mITnv8J+xnF8qwW+mDmSsICGNwDxdm/4ydeHDx/mscceY+nSpfj6+tK7d288PT1JTU0lOjqaAwcOMGHCBAYMGEBiYiIJCQmMGTOGefPmUVhYyPLly+nduzcHDhzghhtu4L333mPChAnExsaSmJjIwIEDefvtt2udKtlcUxM9PDwYMmQIa9ascRwps9vtrFmzhunTpzd6fyIibYGnlw+9B10Cgy5xbDtdkEv6jk3k7NuEe2YKofk76WIcobORSeeCTNj3JewD+2cW0m0RZLWLwt5pEAG9hpGzP5mhO/5C6E9t9BPVRr/N0V+kLVC/W58j+4Uv6Wo/zIa3nmD47U+bHanJbF39BoOLt1BquNH+hhea5YRXi9VK7GU3UTHyBhI//Bddv59PGNmEfv8YB7b/m5zhjxJz2U062dZkFoulUdMDAS4I8WPexGge/V8qFYaBzWJh7sQBXBDSfEc777//fsaOHcu4cZVHp93c3IiMjKx2ntiuXbt455136NWrFwMGDMDPz49Nmzbx8ssv89JLL/HCCy9U2+euXbtYunQpkZGRjB49mm+++YaLL655UnlQUBBBQUGNzlxQUMC+ffsc19PS0khJSSEoKMhx9GzmzJlMmTKFuLg4hg0bxvz58yksLGTatGmNfjwRkbbKxy+AyPgrIP4Kx7bck9kc2vEt+fsT8czaRnjhTsIs2XSzH6Jb7iHI/Qx2V2+jb7MYDN72JJnx43VkrA1RIdYCBbQPJmnoYwRvfpAh6a9xaO+vW8XaYoX5OXTe+BQASV1uY3iv5j2x3+bmxrDr7qP4ytvZ+P4zRO77d+Wi0N/eza7EF7EkPEm/M944xTVMHtqVS/qEcCD7NN2DfZq1a+KqVatYu3Ytu3btqrY9Ojq6WiHWt29f+vbtC0BkZCQJCQmOcR9//HGN/fbt25eoqCgABg0axIEDB2otxM7Vli1bGD16tOP6zJkzAZgyZQpLliwBYPLkyRw/fpzHH3+cY8eOERsby6efflrnOmAiItIwAUHBBFw8AS6e4NiWfewQh3d+y+m0JHyyv6d7USoBlsJq93Oz2MlO361CrA1xiUMCX375JRaLpdbL5s2bAXjiiSdqvd3X17dBj3HixAkiIiKwWCzk5OQ047NpmMFjb2eb11A8LOXkvXsfht1udqTztu2tPxLKCY5YQhl0y/9z2uN6efty4a1PwAPb2BB+G0WGB5FlO+n3ySS2Pj2W9F1JTssiTaNTgDfDe3Zo9tb1V199NadOnapx3tQbb7zBBx984Lju6enp+NlqtTquW61WKipqnth95nibzVbrmPMxatQoRzfDMy9VRViV6dOnk56eTklJCZs2bSI+Pr5Jc4iISKXgsC7EXHoTw+94hphHVlN0+1dUGNWnpJcbVoK79TMpoZjBJQqxESNGcPTo0WqXO++8kx49ehAXV9n2/KGHHqoxJioqikmTJjXoMe644w4GDhzYnE+jURxrixke9C/9ni0r/2l2pPOSviuJuCOVXSCzfvWUKY0zAtoHM/y3L5L/20QSg8ZTYVgYdPo7It6+jMT5N3Ps0L6z70RERETkPIV17U3SwCcc5zzbDQvrej+qo2FtjEsUYh4eHoSFhTkuHTp04IMPPmDatGmOE9z9/PyqjcnMzGTnzp3ccccdZ93/v/71L3JycnjooYea+6k0SniPfnzf8/cA9Er5K6eOHzU50bkx7HYKlj+Au6WCrT4jiL3sJlPzdOzcg2H3/5eMW74k2fdibBaDYTkfE/jqhWxceA+5JzLJzPiR1G8/JDPjR1OzioiISOs07PoZFAx/GIAv7TF863+VyYnE2VxyHbH333+fG2+8kfT0dCIial/I9b777mP16tXs2bOn3n3t3LmTyy67jE2bNrF//35Gjx7NqVOnCAwMbHCe5lxvpXJtsWH0sB9gc+BYhs54u0n37wxbVi4kLvkRigwPTk37hvDufc2OVM3uLWuwr55DVOl2AE4bHnhRitUCFYaFJHUxahL1rSMlrZ/WEXMtek1EnGT3x/D2zWyz9+BW699I/GMCXo3o7CstU6teR+y1115jzJgxdRZhxcXFvPnmm8yaNave/ZSUlHDzzTfzzDPP0LVrV/bv39+gxy8pKaGkpMRxPS8vr+HhG6lybbHnsK+6gaE5n7jc2mJ5OSfonjwPgJQedzC8hRVhAP3iLsMYPJrvv3yPwK+foBuHHbfZLAZDt83hxx2LKfQIpszdn3IPf+xegVi8A7F6t8fdrz3ufkF4t+uAT0AH/AJD8GsX2CRdGbW+iIiISCvWvhsA3azHySsu55PUo1w3qPa/b6X1MbUQmzVrFn/729/qHbNr1y769fv5xMWMjAw+++wz3nnnnTrvs3z5cvLz85kypf41qmbPnk1kZCS33npro3LPmzePJ598slH3OR+Va4tNIP7ECvy/eMil1hbb+eYjXEgOhyzhDL7pcbPj1MlitRJz6Y1sd/OEtbdVv80CPe0HoPgAFDdsf+WGlXyLL4UWP07b2lHs5t/oIi7x/fkM2faE1hcRERFprQIrlxQJoAA/TrM08ZAKsTbE1KmJx48f58SJE/WOueCCC/Dw8HBc/3//7//x4osvcvjwYdzd3Wu9z2WXXYa/vz/Lly+vd9+xsbFs377dcZ6ZYRjY7XZsNht//OMf6yy2ajsi1qVLl2adwpF7KpuyF4YQTA4buv6W4bc/0yyP05R+3PYd3d+/CpvFYPulbxB9yYSz38lkmRk/EvzKEGyWn/+3qDAsbIl5EqvVRsXpUxhFOViLc7CV5OJelodneT7eFfn42vPxNwrwsJSfV4Zyw0qBxZsAo5Az1/gtN6ycuGuLyx4Z09TEtk1TE12LXhMRJ/pbDyg6yVWlf2WnvStfzBxJr47Ob2omTcclpiaGhIQQEhLS4PGGYbB48WJuu+22OouwtLQ01q1bx8qVK8+6v/fff5+ioiLH9c2bN3P77bfz9ddf07Nn3X/senp6Vms/7QwB7YNJGvY4wYkzGZK+iIM//JqufWKdmqEx7BUVlK/8P2wWgyS/UQxxgSIMIDSiJ4kDn2Dwtidxs9gpN6wkD5xD/MQHGnR/w26nqKiQ/JxsCnOzKco7QWn+ScoKT/6iiMupLOLK8vG25+NrL3AUcW4WO4EUQvWutlpfREREpDVq362yEIsoZedBWLb5IH8cF2V2KnEClzpHbO3ataSlpXHnnXfWOWbRokV06tSJsWPH1rht+fLlzJ49m927dwPUKLays7OBygVZG9Osw1kGXzmN77ctJaZ4M/nv3Ycx66smOQ+pOWxZ8SLDyndTaHjR5eb5ZsdplGHXzyAzfjzZ6bsJ7taPYY0ofCxWK96+7fD2bQedezTqcc8s4jJ/3Eb/NVOwnnFkTuuLiIiItEKBXeHIVq7oXMKzB+H95MM8NKYvnm5q2tHatcy/4uvw2muvMWLEiGrnjJ3JbrezZMkSpk6dis1W85c3Nzf3rF0UWzKL1UqIY22xbWz+YIHZkWqVk32M3tufBWB7n3vo2MiCpCUIjehJ/4vGOfXoU1UR17FzD6IvmcCWgU84Fns0DEjqP1tHw0RERFqbwMqGHb3cTxDm78XJwlJW78g0OZQ4g0sVYm+99RbffvttnbdbrVYOHTrEX/7yl1pvnzp1KvWdEjdq1CgMw2iRR8OqnLm2WO/v/9Yi1xbb89bDtCefNGs3hkyqv3Ol1G3Y9TPIuj2RbAKwWMDNr+HTeEVERMRF/NSww5p7kBuHdgHg7c0HzUwkTuJShZhUGnLTn9hv7U578tn33xlmx6lmz5a1DD3xIQBFVzyNu4dzz6VrbTp168PeTpXn11l3vGdyGhEREWly7btX/ptzkBvjIrBY4Nt9J0g/UWhqLGl+KsRckLuHJ6VXPY/dsDA091NSv/3Q7EgAVJSXY/vkIawWg80BY4i68EqzI7UKHUf8GoCogk3k5dTfZVRERERczE9TEzmVTkSgN5f0rpwB8/bmQyaGEmdQIeai+sVdxuaQ6wAI+OIPFBeZ/63JlvefpVfFj+ThS4+bnzM7TqtxQf9hpFu74GkpY/e6t8yOIyIiIk0psHI6IqX5UHSKm4dVXn93SwZlFXYTg0lzUyHmwiJvfZZsAuliHGHrW3NMzZJ97BCRu14AYFfkAwSHdTE1T2tisVo50mUcAF576l8bT0RERFyMuzf4hVb+nJPOZZGhBPt5kl1QwppdWeZmk2alQsyF+Qd2IH3YEwAMObiY9D0ppmVJW/og/pxmr60Xcdc/aFqO1qrLxb8BIKpoK9nHNFVBWoa0tDRGjx5NVFQU0dHRFBaaf2ReRMQl/dSwg1PpuNusTIqLANS0o7VTIebiBl85he+9h+FhKafg/ekYducfwt654ROG5n6G3bBgjHsOm5tLLU/nEiJ6DeAHtz64Wez8+OV/zY4jAlR2on3qqafYuXMnX331ldMXuhcRaTWqzhPLqSy8bvqpe+JXPxwn49Rps1JJM1Mh5uKqry223elri5WVluDz+R8A2NxhPH0Gj3Lq47clJ3uMByDgx5UmJ2mbZs2ahaenJ7fccovZUVqEHTt24O7uzsUXXwxAUFAQbvoSRkTk3LSvKsTSAejWwZeLenXAMOCdLRkmBpPmpEKsFQjv3pfve90NOH9tsaR35tHdfpBT+NP3lmec9rhtUc/Rt2E3LPQr28nRdNddmNxVzZ49m+eee46lS5eyb98+s+PUa/369YwfP57w8HAsFgsrVqyoddyCBQvo3r07Xl5exMfHk5iY2ODH2Lt3L35+fowfP57Bgwczd+7cJkovTeHQoUOMGjWKqKgoBg4cyLvvvmt2JBGpT9XUxJyfpyLeNLRy27tbDlGuph2tkgqxVmLI5D+esbbYA055zKzDaUTv/RcA+wY+RGBwmFMet60KCe/OLs9oAA58pemJzhYQEMAdd9yB1Wpl+/btZsepV2FhITExMSxYUPcR8mXLljFz5kzmzJlDcnIyMTExjBkzhqysn08Mj42NZcCAATUuR44coby8nK+//pp//vOfbNiwgc8//5zPP//cGU9PGsDNzY358+ezc+dOVq9ezYwZM3QOn0hLdkYL+ypX9A+lvY87R3OL+eqH4yYFk+akQqyVqL622GekftP809cOLZ2Br6WY3W6RDJkwvdkfT6Cg97UAdExvGWvHtTXl5eX4+PiQmppqdpR6jR07lj//+c9cd911dY55/vnnueuuu5g2bRpRUVEsXLgQHx8fFi1a5BiTkpJCampqjUt4eDidO3cmLi6OLl264OnpyVVXXUVKSooTnp00RKdOnYiNjQUgLCyM4OBgTp48aW4oEanbmUfEDAMATzcb1w+ubNqxNFGNulojFWKtSLW1xdY80qxri23/6n8MKfiSCsOC+zXPY7XZmu2x5Gd9R/+aUsNGz4o00nclmR3HPLmHIW195b9O9Kc//YmCggKnFWJz587Fz8+v3svBg43vqFVaWkpSUhIJCQmObVarlYSEBDZs2NCgfQwdOpSsrCxOnTqF3W5n/fr1REZGNjpLW9WQ6aPnM3X0TElJSVRUVNCli5YVEWmxAroAFigvgsKfj37dNKyyQFu3J4vMvGKTwklz0ZnVrUzkrc9yfP46uhhH2PDW4wy/o+kXVi4pPk3gl38EYHPoJC4cOKLJH0NqFxgcRorPUGKLNnLk2//SLXKI2ZHOnWFA2Tl0gkp5Cz75Axh2sFhh7NMQ28gGGu4+YLE06i5JSUksXLiQcePGOa0Q+/3vf8+NN95Y75jw8PBG7zc7O5uKigpCQ0OrbQ8NDWX37t0N2oebmxtz587lkksuwTAMrrjiCq6++upGZ2mrqqaP3n777UycOLHG7VVTRxcuXEh8fDzz589nzJgx7Nmzh44dOwKVU0fLy8tr3Hf16tWO34uTJ09y22238corrzTvExKR8+PmAf6dIS+jcnqiX+X/5706+jGsexCJB07y7pZDTL+0t8lBpSmpEGtl/AM7kBw/h5BNM35aW+w3dOsb26SPkfz2Uww3jpBNIFG3/LVJ9y1nVx41EZI20uXwxxj257BYXfTAdtlpmNv4IqIaww4fP1R5aYxHj4CHb4OH2+12fve73zF9+nTi4+O59dZbKSsrw93dvcH7OHLkCA8//DBvvvlmg+8TFBREUFBQg8c729ixYxk7dqzZMVzS2f7bnTl1FGDhwoV89NFHLFq0iFmzZgGcdSpoSUkJ1157LbNmzWLEiPq/MCspKaGkpMRxPS8vr4HPRESaTGDXykIsJx26DHVsvmlYFxIPnOTtzYe4Z1QvrNbGfZEoLZeL/gUn9Rk0Zgrfe8fjYamgsInXFjuStptBaa8CcGDIo/gHdmiyfUvDRI6aTJHhQYRxjL0pX5sdp0148cUXyc7O5qmnniI6OpqysrIGHzmqEh4e3qgiDJpvamJwcDA2m43MzMxq2zMzMwkLU9MdszXF1FHDMJg6dSqXXnopv/nNb846ft68eQQEBDgumsYoYoJftLCvclV0J/y93Mg4VcQ3+7JNCCbNRUfEWqHKtcVe5PTii4kq3U7iBy8x7Lr7m2TfWe/OINxSxg6PGIaMu6tJ9imN49sukCT/ixiSv46Tm96CwSPNjnRu3H0qj0w1Rt4RWDCs8khYFYsN7t0E/o04uubu0+Chhw8f5rHHHmPp0qX4+vrSu3dvPD09SU1NJTo6mgMHDjBhwgQGDBhAYmIiCQkJjBkzhnnz5lFYWMjy5cvp3bs3Bw4c4IYbbuC9995jwoQJxMbGkpiYyMCBA3n77bex1DJVsrmmJnp4eDBkyBDWrFnDtddeC1Qe9VuzZg3Tp6vxjtmaYurot99+y7Jlyxg4cKDj/LP//Oc/REdH1zp+9uzZzJw503E9Ly9PxZiIs1U17DhVvRDzcrcxcXAES747wNubD3JJnxATwklzUCHWSoV378vG3ndz4b759Pn+b5y86HqCOnY+r32mfLGU2NMbKDNs+E2c77pT4loBa/QN8N06LshcTUV5OTZXXEjXYmnU9EAAgnvD+BfgwxlgVFQWYePnV25vJvfffz9jx45l3LhxQOW5UZGRkdXOE9u1axfvvPMOvXr1YsCAAfj5+bFp0yZefvllXnrpJV544YVq+9y1axdLly4lMjKS0aNH88033zgWRj7TuU5NLCgoqLbWWVpaGikpKQQFBdG1a+UH/cyZM5kyZQpxcXEMGzaM+fPnU1hY6JgKJ67tV7/6FfZGzIbw9PTE09OzGROJyFlVtbDPqTnT4aZhXVjy3QFW78jkeH4JIe30/2troL+kW7EhNz7Kj7YeBFLAj2/+33ntq6gwn47fPg7AlvBf063f4KaIKOco6pKJ5OFLR06ya9MnZsdxrsG3wYztMGVV5b+Db2u2h1q1ahVr166tUUhFR0dXK8T69u1L3759sdlsREZGOqaUVR0x+6W+ffsSFRWFxWJh0KBBtY45H1u2bGHQoEEMGjQIqCy6Bg0axOOPP+4YM3nyZJ599lkef/xxYmNjSUlJ4dNPP61xFEacT1NHRdqoOqYmAvQL8ye2SyDldoP3kzOcHEyaiwqxVszdw5PysWesLfb1B+e8r5SljxNuZHGMYGJ+/ecmTCnnwtPLh93tRwFwOmmZqVlMEdAZelxc+W8zuvrqqzl16lSNP37feOMNPvjg5/+fzjySYLVaHdetVisVFRU19nvmeJvNVuuY8zFq1CgMw6hxWbJkSbVx06dPJz09nZKSEjZt2kR8fHyT5pBzc+bU0SpVU0eHDx9uYjIRaVaOtcQOQS1HtG/5qZX9ss2HMH5aa0xcmwqxVq5v3KWOtcUC157b2mKH9n7PkENvAHB0+OP4+AU0aUY5Nz6DJwPQ9+RaSku0toiIKykoKCAlJcXR+bBq+mhV85WZM2fyyiuv8Prrr7Nr1y7uvvtuTR0Vae3ahYPVDexlkH+0xs1Xx3TCz9ONtOxCNu7XAu2tgQqxNiDy1mc5TnsijKOkvPlYo+5r2O3kvDcDD0s527yGEnv52btviXNEDh9HNoEEUMjOb1aYHUdEGuFs00c1dVSkDbK5Va4lBrVOT/TxcOOa2MoGTUsTG98xV1oei6Fjm+ctLy+PgIAAcnNz8ff3NztOrZI/WczgTTMoNWwcvfmLBp/jlfTxYoYkzqDEcOf4b74koteAZk4qjbFxwZ1cePxdtvgnEDfzfbPj1Ku4uJi0tDR69OiBl5eX2XHEyep7/V3hPbSt0WsiYpLXx0PaerjuZYi5qcbNqYdzufrFb/CwWdn06GW09/UwIaScTUPfQ3VErI2ovrbYfdgbcE5KQd4puiQ+BUBy16kqwlqg9vG3ABCV+zWnC3JNTiMiIiLnpY4W9lUGdA5gQGd/Sivs/G/rYScGk+agQqyNsFitdLzpRU4bnkSVpZL0wUtnvU/qW3+kIyc5bAll0M1PNH9IabQ+g0dx2BKKj6WEnV+9Y3YcEREROR+B3Sv/raWFfZWbhlYWa0sTD6pph4tTIdaGdOrWl2297wGgz7a/cSKz7vanaTs3E3d0KQDZF/8ZLx8/p2SUxrFYrRwMHwuAbcf/TE4jIiIi56WeFvZVJsSG4+1uY19WAUnpp5wUTJqDCrE2Jm5y5dpiARSy/63a1xYz7HaKVvwfbhY7W31/RcylNzo5pTRG2EW3AtC/cBO5J4+bnEZERETO2VmmJgK083JnfEwnAJYmHnJGKmkmKsTaGDd3DyrGzf9pbbHVta4ttuXDhUSVbue04UmnyfOdH1IapUfUUNKs3fCwVLBn3ZtmxxEREZFzFfjTEbG8w1BRXuewm35aU+yj7UfILSpzRjJpBirE2qA+g0exOWQiUHNtsdxT2Vyw9a8AfH/BXYR17W1KRmmczK5XA+Dzw3KTk4iIiMg58wsFmycYFZBX9ykkg7oE0je0HcVldj5IUdMOV6VCrI2KvPUZsggiwjjK1jf/5Ni++80/0IFc0q0RDLmpcWuOiXm6jrwNgMji78k+Uvd0BhEREWnBrFYI7FL5cz0NOywWCzcPqxy3NPGQmna4KBVibZR/YAcyLpwDwJBDr5O+K4l9339D3PHKhg/5l87Dw1NrPbmK8B792OPWD5vFYN+X/zE7joiIiJyrqumJ9ZwnBnDdoAg83azsOprHtgwtYeOKVIi1YYOuuI0U7wvxsFRQ/N7vcVvxO2wWgy3tLmPAr64xO5400qmela9Z+/0rTU4iIiIi56yqYUc9nRMBAnzcuSq6qmlH3UfPpOVSIdaGWaxWQm/6ByWGG30rfqC7kYFhQFnoQLOjyTnoNfo3VBgW+pbv4fD+XWbHERERkXPhaGF/9uLqpqGV0xNXfn+EgpK6m3tIy6RCrI2z2txw5+f/cS0WGLr3BTIzfjQxlZyL4LCu7PKKAeDQek1PFBERcUkNaGFfZViPIC4I8eV0aQUffn+kmYNJU1Mh1sYdT9+J1VJ9m5vFTnb6bnMCyXkp6lvZDTP04CqTk7Q+I0eOxGKx1LjcdtttZkcTEZHWJLB75b8NOCJmsVi4eWhl4abpia5HhVgbF9ItigqjeiVWblgJ7tbPpERyPvqM/jWlhhs97Omk7dhkdpxWwzAMtm7dyrPPPsvRo0erXf75z3+aHU9ERFqTqqmJ+UehvOSswycO7oy7zcK2jFx2HFHTDleiQqyNC43oSdLAJyg3Kn8Vyg0ryQPnEBrR0+Rkci4C2gezw3cYAMe+1eLOTWXv3r3k5+dzySWXEBYWVu3i5+dndjwREWlNfDqAuw9gQM6hsw7v4OfJmP5hALydePbx0nK4mR1AzDfs+hlkxo8nO303wd36MUxFmEuz978eNn9Ht6OfYtjtWKwt+/uWwsLCOm+z2Wx4eXk1aKzVasXb2/usY319fRudMSkpCTc3NwYOVCMbERFpZhZLZQv747sqOycG9zrrXW4e1pVV246yYuthHr0qEm8PmxOCyvlq2X+hidOERvSk/0XjdCSsFYgaNZnThifhRiZ7kteZHees/Pz86rxcf/311cZ27NixzrFjx46tNrZ79+61jjsXycnJVFRU0KFDh2r7+t3vfgdAcHBwjfscOHCAuLi4atumTp3KqlWV5+9lZGQwceJEevbsSVxcHJMmTSIzM7PO/YmISBvSwBb2VYZf0IGuQT7kl5SzapuadrgKFWIirYy3bzt2BlwMQM6mpSanaR2Sk5O5+eabSUlJqXaZN2/eOe3PMAwmTJjAuHHj+PHHH9myZQv3338/x48fb+LkIiLikhrRwh7AarUw+adW9m9v1vREV6GpiSKtkHvsJFj/Bb2Of05FeTk2t5b7v3pBQUGdt9ls1adWZGVl1TnW+ospmAcOHDivXGdKTk7mL3/5C716nX16SEOsWbMGPz8/7rjjDse2iy++uEn2LSIirUDgT4VYA1rYV5kUF8HfP/+BpPRT/JCZT5/Qds0UTpqKjoiJtEKRF11LDn4Ek8PO7z4yO069fH1967yceX7Y2caeeX5YfWMba//+/eTk5BATE3Nez/NMO3fuZPDgwU22PxERaWUaOTURoGM7Ly6L7Aiolb2rUCEm0gp5eHqxJ+hSAIqS3zY5jWtLSkoCIDQ0lGPHjlW72O32Ou9nsVgatV1ERMShkVMTq9w0rLKAW771MMVlFU2dSpqYCjGRVspvyE0A9Mv5kpLi0yancV3JyckA9O7dm06dOjku3bt3p7y8vM77dejQgVOnTlXbdvLkSYKDg4mMjGTr1q3NmltERFxY1RGxwuNQWnfH4F+6pHcInQO9yTldxmc7jjVTOGkqKsREWql+8WPIIgh/TrNz/f/MjuOy5s2bh2EYNS7FxcV4eHjUeT8/Pz8CAwP57rvvgMouidu3b6d///4kJCSQl5fHkiVLHOO/+eYbUlNTm/vpiIiIK/BuD54BlT83YC2xKjarhRvjKpt2aHpiy6dCTKSVsrm5sT90DAD27e+ZnKZ1O3XqFBEREY7L0qWV3Spff/11Zs2aRWxsLNdeey0vv/wyfn5+WCwWVqxYwYoVK+jZsyf9+/fnxRdfJCQkhPLycjw9PU1+RiIiYrr2jT9PDODGoRFYLbBx/0n2H6+7IZaYzyUKsS+//BKLxVLrZfPmzQA88cQTtd5+tpPza7vP22/rnBppHTpceAsAUXnfUpifY26YVqyiooKMjAzH5eabbwZgwIABrF+/npSUFLZs2cIVV1zhuE/Xrl1ZsWIFP/74Izt27GDZsmWEhoayY8cOevToYdZTERGRluIcOicCdArwZlTfyqYdy9TKvkVziUJsxIgRHD16tNrlzjvvpEePHo4FUx966KEaY6Kiopg0adJZ97948eJq97v22mub+RmJOEevmF+RYemEt6WUXev0BUNLt3jxYm655RaeeOIJs6OIiIjZqgqxRh4RA7j5p6Yd7yVlUFped2MpMZdLFGIeHh6EhYU5Lh06dOCDDz5g2rRpjg5kfn5+1cZkZmayc+fOauv01CUwMLDafX/ZMlvEVVmsVjI6XwWA+y6dJ9bSTZs2jR07dpCQkGB2FBERMds5tLCvMrpvCKH+npwoLOXznZlNHEyaiksUYr+0cuVKTpw4wbRp0+oc8+qrr9KnT58GLZJ67733EhwczLBhw1i0aBGGYTRlXBFTdfrVrQBEnd5CTrY6KImIiLiEc2xhD+BmszJpSGXTjrc3q2lHS+WShdhrr73GmDFjiIiIqPX24uJi3nzzzQYdDXvqqad45513+Pzzz7n++uu55557ePHFF+u9T0lJCXl5edUuIi1Vt36D+dHWA3dLBXvWvWl2HBEREWmIczxHrMrkoV2wWODrvdkcOqllbFoiUwuxWbNm1dmEo+qye/fuavfJyMjgs88+q7fIWr58Ofn5+UyZMuWsGR577DEuuugiBg0axCOPPMIf/vAHnnnmmXrvM2/ePAICAhyXLl26NOwJi5jkeLfxAPjtXWFuEBEREWmYqqmJxTlQnNvou3cJ8uFXvYIBHRVrqUwtxB588EF27dpV7+WCCy6odp/FixfToUMHrrnmmjr3++qrr3L11VcTGhra6Ezx8fFkZGRQUlJS55jZs2eTm5vruBw6pI400rJ1H3UbAJEl28k6nGZyGhERETkrTz/w6VD58zlMT4Sfm3a8uyWD8go17Whp3Mx88JCQEEJCQho83jAMFi9ezG233Ya7u3utY9LS0li3bh0rV648p0wpKSm0b9++3nV8PD09tc6PuJSwrr3Z5R5FZNlO9n/5Bh1/PcfsSCLSzE6fPk1kZCSTJk3i2WefNTuOiJyLwK5w+kTl9MSw6EbfPSEylGA/D7LyS1i7O4sr+oc1Q0g5Vy51jtjatWtJS0vjzjvvrHPMokWL6NSpE2PHjq1x2/Lly+nXr5/j+ocffsirr75Kamoq+/bt41//+hdz587lvvvua5b8ImbK6zUBgA5pH5qcRESc4S9/+QsXXnih2TFE5HwEnnvDDgAPNyvXD6nsqfC21hRrcVyqEHvttdcYMWJEtWLqTHa7nSVLljB16lRsNluN23Nzc9mzZ4/juru7OwsWLGD48OHExsby8ssv8/zzzzNnjo4WSOvTa9StlBtWepfv5dC+7WbHEZFmtHfvXnbv3l3rl5Ii4kLan/taYlVuGlo5PfHLPVkcySlqilTSRFyqEHvrrbf49ttv67zdarVy6NAh/vKXv9R6+9SpU6u1pr/yyivZunUr+fn5FBQUkJKSwu9+9zusVpf6zyLSIB1CI9jpPRiAjK//a3IakbZr/fr1jB8/nvDwcCwWCytWrKgxZsGCBXTv3h0vLy/i4+NJTExs1GM89NBDzJs3r4kSi4hpHGuJnXuzjR7Bvlx4QRB2A97ZoqNiLYkqDpE2pKTfdQCEH1qFYddJuyJmKCwsJCYmhgULFtR6+7Jly5g5cyZz5swhOTmZmJgYxowZQ1ZWlmNMbGwsAwYMqHE5cuQIH3zwAX369KFPnz7Oekoi0lwCu1f+e44t7KtUNe14Z/MhKuxaL7elMLVZh4g4V7/Rt1Cy9Qm62TP4MXUjPQeOMDuSSJszduzYeqcMPv/889x1111MmzYNgIULF/LRRx+xaNEiZs2aBVQ2lqrLxo0befvtt3n33XcpKCigrKwMf39/Hn/88TrvU1JSUq1bsNbHFGkhHEfE0sEwwGI5p92M6R9GoI87R3KLWf/DcUb369iEIeVc6YiYSBvSLiCIHX6VJ+9nbdDizo0xcuTIWtc6vO2228yOJq1IaWkpSUlJJCQkOLZZrVYSEhLYsGFDg/Yxb948Dh06xIEDB3j22We566676i3Cqu6j9TFFWqDAn/5fLC2AolPnvBsvdxsTB1U27ViaqDXFWgoVYiJtzYDrAehx9DPsFRUmh3ENhmGwdetWnn32WY4ePVrt8s9//tPseNKKZGdnU1FRUWMdzNDQUI4dO9Zsj6v1MUVaKHdv8Pvp/eDUgfPa1c3DKou6NbuzyMorPs9g0hRUiIm0MVEjJ1FgeBPGcX7YssbsOC5h79695Ofnc8kllxAWFlbt4ufnZ3Y8kTpNnTq1QWuIeXp64u/vX+0iIi3Eebawr9I7tB1x3dpTYTd4NymjCYLJ+VIhJtLGePn4sSvwEgByNy81OU1l44LCwsJqHU1LS0spLCysds7KmWPtZzQaKSsro7CwkOLi4gaNPRdJSUm4ubkxcODAc7q/SEMFBwdjs9nIzMystj0zM5OwMC3EKtImNUEL+yo3/dS04+3NB7GraYfpVIiJtEGesTcC0Dv7C8rLSk3N4ufnh5+fH9nZ2Y5tzzzzDH5+fkyfPr3a2I4dO+Ln58fBgz9/K7hgwQL8/Py44447qo3t3r07fn5+7Nq1y7FtyZIl55QxOTmZiooKOnTo4Mjr5+fH7373OwDc3NyIjY11XIqKKtdpycjIYOLEifTs2ZO4uDgmTZrk+AM7ODj4nLJI6+bh4cGQIUNYs+bno9V2u501a9YwfPhwE5OJiGmqGnacZ+dEgHHRnWjn5cahk0V89+OJ896fnB91TRRpgyIvGs+pr/wJIo9t337IwFHXmx2pRUtOTubmm2/mySefrLY9KCgIgMDAwBpd7AzDYMKECdxzzz3873//A+Drr7/m+PHjNc7/kbaloKCAffv2Oa6npaWRkpJCUFAQXbt2ZebMmUyZMoW4uDiGDRvG/PnzKSwsdHRRFJE2pommJgJ4e9i4blBn3tiQztLNB/lVb30paCYVYiJtkLuHJz90uJT4Eyso2foOmFiIFRQUAODj4+PY9vDDDzNjxgzc3Kq/RVWto+Tt7e3Ydu+993LXXXdhs9mqjT1w4ECNsVOnTj2njMnJyfzlL3+hV69eDb7PmjVrahypu/jii8/p8aV12bJlC6NHj3ZcnzlzJgBTpkxhyZIlTJ48mePHj/P4449z7NgxYmNj+fTTT1XAi7RVZ7awbwI3De3KGxvSWb3jGCcKSujg59kk+5XGUyEm0ka1G3ozfLqCfjlfUVxUiJe3ryk5fH1rPq6HhwceHh4NGuvu7o67u3uDxzbW/v37ycnJISYmps4xOTk5xMbGAhAXF8err77Kzp07GTx4cKMfT1q/UaNGVTsnsjbTp0+vMTVXRNqo9mccETuPtcSqRIX7ExMRwPcZubyfnMFvL+nZBCHlXOgcMZE2qt/QyzlGMO0sRexa/57ZcVqspKQk4Of24WdeqhqBVE1NTElJ4dVXXzUzroiItDb+EWCxQnkxFGQ1yS5vdjTtOHTWL4ak+agQE2mjrDYbB8LGAGBsVyFWl+TkZAB69+5Np06dHJfu3btTXl5e5/0iIyPZunWrs2KKiEhr5eYB7cIrf26i6YnjY8Lx9bCx/3ghiWknm2Sf0ngqxETasODhvwagf/4G8nP1RlybefPmYRhGjUtxcXGt0yerJCQkkJeXV61T4zfffENqaqoTUouISKvSvukadgD4erpxTWxlcbc0sWn2KY2nQkykDesZPZyD1s54WsrYvc78NcVaE4vFwooVK1ixYgU9e/akf//+vPjii4SEhJgdTUREXI2jhf2BJtvlTUMr9/lx6jFyTpu7lE1bpWYdIm2YxWrlcMQ4uh78N567lwP3mh3JJZ25BtqZunbtyooVKxp1HxERkRqasIV9lYERAUR18mfn0TyWbz3MtIt6NNm+pWF0REykjYu4+FYAooqSOJl12OQ0IiIiUoNjamLTnCMGlTM3bh7WBaicnqimHc6nQkykjevSO4a9tl64Wezs/fJNs+OIiIjILzmmJjZdIQYwYVBnvNyt/JBZwOsb0jmaW9Sk+2+so7lFfPdjdpvJoUJMRDjRYzwA7fZ+YHISERERqaFqamJuBtgrmmy3/l7u9A8PAOCJlTu46K9rWbbZnOYdyzYf5KK/ruWWVza1mRw6R0xE6DHqN9j3zieqLJVjB/cS1rW32ZFERESkin84WN3AXgb5RyEgokl2ezS3iOSDpxzX7QbMen873+7LxsfDeWXC6dJyVn5/tEXmePR/qVzSJ4ROAd5N/ngqxESE0Iie7PQcQFTpdg589R/CfvOU2ZFERESkitVWWXydOlDZsKOJCrG07EJ+eWqYAdWKEbO0lBwVhsGB7NMqxESk+eT3mgA7txN8YBXQfIWYTgZum+x2u9kRRERcW2C3ykLsVDp0G9Eku+wR7IvVUnnkp4oF+N3IC2jn5d4kj9EQ+cVlvPzVfs78C6Gl5LBZLHQP9mmWx1MhJiIA9Bl9K2U75tGr4kcO/pBC1z6xTbp/d3d3LBYLx48fJyQkBIvF0qT7l5bJMAxKS0s5fvw4Vqu13kWwRUSkHlUNO5qwc2KnAG/mTYzm0f+lUmEY2CwW5k4cwOSf1hhzph7Bvi02R3McDQMVYiLyk/YhnfjeZwgxRYkc/vq/TV6I2Ww2IiIiyMjI4MCBA026b2n5fHx86Nq1K1arekSJiJyT9k2/lhjA5KFduaRPCAeyT9M92KfZig7lqEmFmIg4lEVOhOREIjI+wrA/jaWJ/2j28/Ojd+/elJWVNel+pWWz2Wy4ubnpKKiIyPmo6pzYxC3sofLImFmFT1vOoUJMRBz6jbqJ4qTH6MIR9m77lt6xFzf5Y9hsNmw2W5PvV0REpFULbJ4jYmIezREREQc///bsbFd5AvCJDVrcWUREpMWompqYlwEVmlnSGqgQE5HqoicB0CNzNfaKpls0UkRERM6Db0eweYJhr1zYWVyeCjERqSbqkonk4UMoJ9iduNrsOCIiIgJgtZ7ROVHTE1sDFWIiUo2Xty+7A0cBkL/lbXPDiIiIyM+aoYW9mEeFmIjU4D34RgD6nFhDWWmJyWlEREQEaLYW9mIOdU0UkRoih4/jxNoAOpDL9998QMylN5odSaTJ9OjR45xa6c+YMYP777+/GRKJiDRQM7awF+dTISYiNbi5e7AvOIEO2e9TlvIOqBCTVmTJkiXndL/u3bs3aQ4RkUbT1MRWRYWYiNQqIP4W+Oh9InO/pqgwH2/fdmZHEmkSI0eONDuCiMi50dTEVkXniIlIrfoOuZQjlo74WorZ+dV7ZscRERGRqqmJ+UehrNjcLHLeVIiJSK0sVivpna4EwLpDhZi0biEhIXTs2LHWS5cuXbjkkktYt26d2TFFpK3z6QDuvpU/ay0xl6epiSJSp9ARt8J7b9C/YCO5p7IJaB9sdiSRZnH8+PE6b6uoqCA1NZVbb72V7du3OzGViMgvWCyV0xOzdkLOAQjuZXYiOQ86IiYideoRNZQD1i54WMrZuWwOmRk/mh1JpFkcP36cnTt31ti+c+dOTp48SUxMDA8++KAJyUREfqGqYYc6J7o8FWIiUieL1copr8o3/OHH/kvwK0NIfH++uaFEmsH06dM5depUje2nTp1ytKyfOnWqk1OJiNQiUA07WgsVYiJSp8yMHxlY+J3jus1iMHjbkzoyJq1OWloaF110UY3tF110EampqSYkEhGpg1rYtxoqxESkTsfTd2KzGNW2uVnsZKfvNimRSPOo7WhYlaKiIicmERE5C7WwbzVUiIlInUK6RVFhWKptqzCsBHfrZ1IikeYxcODAWhd6fuONN4iOjnZ+oCaQlpbG6NGjiYqKIjo6msLCQrMjiUhT0DlirYa6JopInUIjepI48AmGbHsSm8UOQHLAZQyN6GlyMpGm9Y9//IMJEybw+uuvM3jwYACSk5PJz89nxYoV5oY7R1OnTuXPf/4zF198MSdPnsTT09PsSCLSFKrOETudDSUF4Olnbh45ZyrERKRew66fQWb8eNJW/IULs98nLH8H9ooKrDab2dFEmkznzp3ZsmULa9ascXRPHDt2LAkJCSYnOzc7duzA3d2diy++GICgoCCTE4lIk/EOBK8AKM6F3EPQMdLsRHKONDVRRM4qNKIn0VOeJw9fuhhH2LZ2mdmRRJrUxx9/zMcff0xJSQk9e/akV69eBAQEcPr06WZ5vPXr1zN+/HjCw8OxWCy1HnVbsGAB3bt3x8vLi/j4eBITExu8/7179+Ln58f48eMZPHgwc+fObcL0ImI6TU9sFXRETEQaxLddIBs6Xc/wo2/gsfmfcPktZkcSaTLvvvtujW0nT54kNTWVf//731x22WVN+niFhYXExMRw++23M3HixBq3L1u2jJkzZ7Jw4ULi4+OZP38+Y8aMYc+ePXTs2BGA2NhYysvLa9x39erVlJeX8/XXX5OSkkLHjh258sorGTp0KJdffnmTPg8RMUlgNzi2XQ07XJxLFGJffvklo0ePrvW2xMREhg4dyhNPPMGTTz5Z43YfH5+znqC8ZMkSnn/+eX744Qf8/f2ZNGkSCxYsaJLsIq3JBeNmUPbKm0SVbmfv1vX0HnSJ2ZFEmsTixYtr3Z6RkcHEiRMbdTSqIcaOHcvYsWPrvP3555/nrrvuYtq0aQAsXLiQjz76iEWLFjFr1iwAUlJS6rx/586diYuLo0uXLgBcddVVpKSk1FmIlZSUUFJS4riel5fX2KckIs7kWEtMR8RcmUtMTRwxYgRHjx6tdrnzzjvp0aMHcXFxADz00EM1xkRFRTFp0qR69/3888/zxz/+kVmzZrFjxw6++OILxowZ44ynJeJyQiN68n3ApQDkrp1vbhgRJ4iIiKCsrMypj1laWkpSUlK189OsVisJCQls2LChQfsYOnQoWVlZnDp1Crvdzvr164mMrPs8knnz5hEQEOC4VBVwItJCVbWwP3XA1BhyflziiJiHhwdhYWGO62VlZXzwwQfcd999WCyVrbX9/Pzw8/u5a8z333/Pzp07WbhwYZ37PXXqFH/605/48MMPq007GThwYDM8C5HWoX3CTPjf58TmrePYwb2Ede1tdiSRZrNhwwb8/f2d+pjZ2dlUVFQQGhpabXtoaCi7dzdsDT83Nzfmzp3LJZdcgmEYXHHFFVx99dV1jp89ezYzZ850XM/Ly1MxJtKSBWotsdbAJQqxX1q5ciUnTpxwTNmozauvvkqfPn0cHaNq8/nnn2O32zl8+DCRkZHk5+czYsQInnvuuXo/gDSFQ9qyngNHkPpRLANKUjjw0XOE3V33lx0irmLo0KGOL/aqnDx5kvbt2/P666+blOr8nG3645k8PT3V3l7ElVQ169DURJfmkoXYa6+9xpgxY4iIiKj19uLiYt58803HPPq67N+/H7vdzty5c3nhhRcICAjgT3/6E5dffjnbtm3Dw8Oj1vvNmzev1vPRRNqKivi7Yf3v6H9sBfm5c2kXoNbY4tree++9atctFgsdOnTA19eXZcuWERUV5bQswcHB2Gw2MjMzq23PzMysNjtERNqwqkKsOBeKcipb2ovLMfUcsVmzZmGxWOq9/HIaRkZGBp999hl33HFHnftdvnw5+fn5TJkypd7Ht9vtlJWV8Y9//IMxY8Zw4YUXsnTpUvbu3cu6devqvN/s2bPJzc11XA4dOtS4Jy7i4qJHTiLdGkE7SxE7Vr1kdhyR89atW7dql65du+Lr6wvAww8/7NQsHh4eDBkyhDVr1ji22e121qxZw/Dhw52aRURaKE8/8OlQ+bOmJ7osU4+IPfjgg0ydOrXeMRdccEG164sXL6ZDhw5cc801dd7n1Vdf5eqrr64xv/6XOnXqBFDtm86QkBCCg4M5eLDuX2pN4ZC2zmqzkRl1B91Sn6Tb3jcoL5uFm3vtR5BFXJ1hGE2+z4KCAvbt2+e4npaWRkpKCkFBQXTt2pWZM2cyZcoU4uLiGDZsGPPnz6ewsLDeKfki0sYEdoPTJyqnJ3ZSfwNXZGohFhISQkhISIPHG4bB4sWLue2223B3d691TFpaGuvWrWPlypVn3d9FF10EwJ49exzTHE+ePEl2djbdunVrcC6RtmjguN9xMvXvdOI4SavfYMi4O82OJNIsfnnuWFPYsmVLtWVZqhplTJkyhSVLljB58mSOHz/O448/zrFjx4iNjeXTTz896xeMItKGtO8GR5J1RMyFuUT7+ipr164lLS2NO++s+w++RYsW0alTp1pPUF6+fDn9+vVzXO/Tpw8TJkzggQce4LvvviM1NZUpU6bQr1+/OtctE5FKXt6+7Ol6EwDttr6MYbebnEjk3IWEhNCxY8cal5CQEI4ePdrkjzdq1CgMw6hxWbJkiWPM9OnTSU9Pp6SkhE2bNhEfH9/kOUTEhVWdJ3ZKDTtclUsVYq+99hojRoyoVkydyW63s2TJEqZOnYrNZqtxe25uLnv27Km27Y033iA+Pp5x48YxcuRI3N3d+fTTT+s84iYiP+sz7gFKDHf6lP/A7s2fmx1H5JwdP36crKysGpfjx487fR0xEZEGUQt7l2cxmmPyexuTl5dHQEAAubm5Tl9vRsRsif+4lWEnP2Srz0UM+sPHZscRF2TGe+jUqVP55z//iY+Pj1Mez9Xoc03EBez9At68HjpGwT0NW+xdnKOh76EudURMRFqe0DEPARBT+B2H9m03OY1Iw/znP/+hoKDAcf3uu+8mJyen2pjy8nInpxIRaYT2Px0RO5UOOq7ikhpciE2dOpXTp083ZxYRcUHd+sbyvXc8VovBkU+fNzuOSIP8cjLIm2++ycmTJx3XMzMzdSRIRFq2gC6V/5YVwumT9Y+VFqnBhZi+PRSRutgumg7AwOOryD2ReZbRIi1PbbP0i4uLTUgiItJA7l7g99Mi7zkHTI0i56bBhZi+PRSRuvQfcTU/2i7A21LKrg9fMDuOSJNojrb1IiJNqr0adriycz5HTN8eikgVi9XKqZjfAtDrwJuUFGsas7R8b731FsnJyeqKKCKuSy3sXVqTNuvQt4cibVfMlbeTRRDB5PD9J6+ZHUekXhdffDFz5swhLi4OPz8/Tp8+zZw5c1i4cCEbN26sNhVfRKTFcrSwVyHmitwaM/itt97ikksuITo6urnyiIiLcvfwZP8Ft9Jx/z8I2f4qxoR7sVjVmFVapq+++gqAvXv3kpSURHJyMsnJyTz66KPk5OToi0URcQ2amujSGlyIVX17mJ+fj7u7O+Xl5cyZM4eLLrqI2NhYQkJCmjOniLiAyKvv5/QLL9PDfoDt33xA9CXXmR1JpF69e/emd+/e3HTTTY5taWlpbNmyha1bt5qYTESkATQ10aU1uBDTt4cicjYBQSFs7HgNFx5/F+O7l0CFmLigHj160KNHDyZNmmR2FBGR+lVNTcw9VLmWmP4edymNmpoI+vZQROrX9aqHqFjyHgOLt5C2czM9ooaaHUlERKR1CogAixXKi6EgE9qFmZ1IGqFJTuCo+uZw7ty5TbE7EXFh4T368X27iwE4vloLPIuIiDQbmzv4d678WeeJuRydSS8iTc5n5AMAxJ5aTfYxfTCIa/jhhx8oLy83O4aISONUTU/UeWIuR4WYiDS5fkMT2O0WiYelnL2r/m52HJEGiYyMZP/+/WbHEBFpnKqGHTkHTI0hjadCTESaxem43wPQL+NdigrzTU4jcnaGYZgdQUSk8dTC3mWpEBORZhGTcCuHLaG0J59tH/3L7DgiIiKtk1rYuywVYiLSLGxubhzqMxWA8F2LsVdUmBtIRESkNQrUETFXpUJMRJpN9NX3kIcvXYwjbFu7zOw4IiIirU/V1MTcDLDrS09XokJMRJqNb7tAdnS6HgCPzf80OY2IiEgr1K4TWN3BXgZ5R8xOI42gQkxEmlXPq2dSZtiIKt3O3q3rzY4jIiLSulhtlQs7g6YnuhgVYiLSrDp27kFK4GUA5K1VK3sREZEm52hhr4YdrkSFmIg0u6DL/g+AmLwvOXZwr8lpRGr3yCOP0KFDB7NjiIg0nlrYuyQVYiLS7HoOHEGqZyxuFjsHPnrO7DgitZo3b54KMRFxTWph75JUiImIU1TE3wtA/2MryM89aXIaERGRViSwe+W/mproUlSIiYhTRI+8nnRrF9pZitix6kWz44iIiLQemproklSIiYhTWG02MvvfAUD3vf+hvKzU5EQiIiKtRNXUxLzDUFFmbhZpMBViIuI0A6/6LSfxJ4zjfL/6DbPjSBs2depUTp8+bXYMEZGm4RcKbl5g2CsXdhaXoEJMRJzGy9uXPV1vAqDd1pcx7HaTE0lb9Z///IeCggLH9bvvvpucnJxqY8rLy52cSkTkHFksENCl8medJ+YyVIiJiFP1vXoGxYY7fcp/YFfiarPjSBtlGEa162+++SYnT/7cRCYzMxN/f39nxxIROXdV54mpc6LLUCEmIk4V1LEz33cYC0DJ+hdMTiNS6ZeFGUBxcbEJSZrO3//+d/r3709UVBT3339/rc9RRFqRQDXscDUqxETE6cLGPAhATOEGDu3bbnIakdpZLBazI5yz48eP89JLL5GUlMT27dtJSkpi48aNZscSkeZU1bBDUxNdhgoxEXG6bn1j+d47HqvF4Minz5sdR9qot956i+TkZMrKWmeHsfLycoqLiykrK6OsrIyOHTuaHUlEmpNa2LscFWIiYgrbr+4DYODxVeRkHzM5jbQ1F198MXPmzCEuLg4/Pz9Onz7NnDlzWLhwIRs3bqzWyKM5rF+/nvHjxxMeHo7FYmHFihU1xixYsIDu3bvj5eVFfHw8iYmJDd5/SEgIDz30EF27diU8PJyEhAR69uzZhM9ARFqcqiNiOkfMZbiZHUBE2qb+w8exb21PelX8SMqq+Qyf+lezI0kb8tVXXwGwd+9ekpKSSE5OJjk5mUcffZScnJxmn5ZYWFhITEwMt99+OxMnTqxx+7Jly5g5cyYLFy4kPj6e+fPnM2bMGPbs2eM4shUbG1trZ8fVq1fj7e3NqlWrOHDgAN7e3owdO5b169dzySWXNOvzEhETBXav/LfgGJQVgbu3qXHk7FSIiYgpLFYrOTG/heRH6H1gKSXFj+Pp5WN2LGljevfuTe/evbnpppsc2/bv309SUhJbt25ttscdO3YsY8eOrfP2559/nrvuuotp06YBsHDhQj766CMWLVrErFmzAEhJSanz/u+++y69evUiKCgIgHHjxrFx48Y6C7GSkhJKSkoc1/Py8hr7lETEbD5B4OEHpQWVa4kF9zY7kZyFpiaKiGlirpxGFkEEk8P3n7xmdhwRAC644AImTZrE3LlzTXn80tJSkpKSSEhIcGyzWq0kJCSwYcOGBu2jS5cufPfddxQXF1NRUcGXX35J37596xw/b948AgICHJcuXbqc9/MQESezWDQ90cXoiJiImMbdw5P9F9xKx/3/IGT7qxgT7sVi1fdD0rx69OhxTlMPZ8yYwf33398MiarLzs6moqKC0NDQattDQ0PZvXt3g/Zx4YUXctVVVzFo0CCsViuXXXYZ11xzTZ3jZ8+ezcyZMx3X8/LyVIyJuKLAbpC1U50TXYQKMRExVeT4Byic/2962A+w/esVRI+seb6MSFNasmTJOd2ve/fuTZqjuf3lL3/hL3/5S4PGenp64unp2cyJRKTZqYW9S1EhJiKmCmgfzMbQa7gw6x2MDQtAhZg0s5EjR5odoV7BwcHYbDYyMzOrbc/MzCQsLMykVCLiEqpa2GtqokvQHCARMV3XsQ9SYVgYWLyFtJ2bzY4jYioPDw+GDBnCmjVrHNvsdjtr1qxh+PDhJiYTkRYvUGuJuRIVYiJiuvAe/fi+3cUAHF+tBZ6l9SsoKCAlJcXR+TAtLY2UlBQOHqz842nmzJm88sorvP766+zatYu7776bwsJCRxdFEZFaaWqiS9HURBFpEXxGzYBV64k9tZrsYwcJDutqdiSRZrNlyxZGjx7tuF7VKGPKlCksWbKEyZMnc/z4cR5//HGOHTtGbGwsn376aY0GHiIi1VQVYqdPQEkBePqZm0fqpSNiItIi9Iu7jN3uUXhYytn7oY6KSes2atQoDMOocTmzkcj06dNJT0+npKSETZs2ER8fb15gEXEN3oHgFVD5s6YntngqxESkxSiK+z0AkYffpagw3+Q0IiIiLshxnpimJ7Z0KsREpMUYeNmvOWwJJZACtn30L7PjiIiIuJ72atjhKlyiEPvyyy+xWCy1XjZvruyw9sQTT9R6u6+vb537XbJkSZ37zcrKctbTE5Gf2NzcONRnKgDhuxZjr6gwN5CIiIirCVQLe1fhEoXYiBEjOHr0aLXLnXfeSY8ePYiLiwPgoYceqjEmKiqKSZMm1bnfyZMn17jPmDFjGDlyJB07dnTW0xORM0RffQ95+NLFOML3a5aaHUdERMS1aGqiy3CJrokeHh7VFrEsKyvjgw8+4L777sNisQDg5+eHn9/PnWG+//57du7cycKFC+vcr7e3N97e3o7rx48fZ+3atbz22mvN8CxEpCF82wWyIfx6hh95A88tC+GKW82OJCIi4jrUwt5luMQRsV9auXIlJ06cqHc9lVdffZU+ffpw8cUXN3i/b7zxBj4+Ptxwww31jispKSEvL6/aRUSaTs9xMykzbESVbmfv1vVmxxEREXEdVeeIndI5Yi2dSxZir732GmPGjCEiIqLW24uLi3nzzTe54447Gr3fW265pdpRstrMmzePgIAAx6VLly6NehwRqV/Hzj1ICbwMgLy1fzc5jYiIiAupOiJWkgtFOaZGkfqZWojNmjWrzmYZVZfdu3dXu09GRgafffZZvUXW8uXLyc/PZ8qUKQ3OsmHDBnbt2tWg4m327Nnk5uY6LocOHWrw44hIwwQlPAhATN6XHDu41+Q0IiIiLsLDF3yCK3/W9MQWzdRzxB588EGmTp1a75gLLrig2vXFixfToUMHrrnmmjrv8+qrr3L11VcTGhra4CyvvvoqsbGxDBky5KxjPT098fT0bPC+RaTxekZfSOqqWAaUpHDgo+cIu7vu8z1FRETkDO27wensyhb2nWLMTiN1MLUQCwkJISQkpMHjDcNg8eLF3Hbbbbi7u9c6Ji0tjXXr1rFy5coG77egoIB33nmHefPmNfg+ItL8Ki6cDl/dyYBjK8jPnUu7gCCzI4mIiLR8gV3hcJJa2LdwLnWO2Nq1a0lLS+POO++sc8yiRYvo1KkTY8eOrXHb8uXL6devX43ty5Yto7y8nFtvVXc2kZYk+pKJpFu74GcpYseqF82OIyIi4hrUwt4luFQh9tprrzFixIhaiykAu93OkiVLmDp1Kjabrcbtubm57Nmzp9b9Tpw4kcDAwKaOLCLnwWqzkdm/8rzN7nv/Q3lZqcmJREREXEBV58QcdU5sySyGYRhmh3B1eXl5BAQEkJubi7+/v9lxRFqV4qJCCv8WSQdy2TL0WeLG3WV2JGlieg9tefSaiLi4fV/Af6+HkEi4d6PZadqchr6HutQRMRFpe7y8ffmh600ABGx9GcNuNzmRiIhICxfYvfLfnIOgYy4tlgoxEWnx+l79AMWGO73L97Lp7blkZvxodiQREZGWK+CntXbLCuH0CXOzSJ1UiIlIixfUsTM/evYF4MIfniH4lSEkvj/f3FAiIiItlbsXtOtU+bM6J7ZYKsREpMXLzPiRfiU7HNdtFoPB257UkTEREZG6BHat/FedE1ssFWIi0uIdT9+JzVJ9jrubxU52+m6TEomIiLRwamHf4qkQE5EWL6RbFBWGpdq2CsNCcLfal7IQERFp89TCvsVTISYiLV5oRE+SBj5BufHzW9Zuz2hCI3qamEpERKQFq5qaqHPEWiwVYiLiEoZdP4MTd21hQ5+HAOhVsovjRw6YG0pERKSl0tTEFk+FmIi4jNCInlx40x/Z5d4fT0sZP37wV7MjiYiItEyOZh2HQGtwtkgqxETEpVisVspGzARg4LH/cer4UZMTiYiItEABEWCxQkUJFGSanUZqoUJMRFxO9MiJ7LX1wsdSwu4VfzM7joiISMtjcwf/nxZ2VsOOFkmFmIi4HIvVSkH8DAAGZLxN7qlscwOJiIi0RFpLrEVTISYiLinmsls4YO1KO0sROz941uw4IiIiLU9VC3t1TmyRVIiJiEuy2mxkD74PgH4H/kthfo65gURERFoaHRFr0VSIiYjLGnTl7WRYOtGefLZ/MN/sOCIiIi2LWti3aCrERMRl2dzcOBp9NwC99i2muKjQ5EQiIiItSNXURDXraJFUiImIS4sZ9zuOEUIwOXy/8iWz44iIiLQcVVMTczPAXmFuFqlBhZiIuDQPTy/SI+8EoNuuVygrLTE5kYjzXHfddbRv354bbrihxm2rVq2ib9++9O7dm1dffdWEdCJiunadwOoO9nLIO2x2GvkFFWIi4vJixk8nm0DCOM7Wj142O46I0zzwwAO88cYbNbaXl5czc+ZM1q5dy9atW3nmmWc4ceKECQlFxFRWW+XCzqDpiS2QCjERcXlePn7s6zUNgE7b/kVFebnJiUScY9SoUbRr167G9sTERPr370/nzp3x8/Nj7NixrF692oSEImI6tbBvsVSIiUirED1hBjn40cU4wtZPF5sdR4T169czfvx4wsPDsVgsrFixosaYBQsW0L17d7y8vIiPjycxMbFJHvvIkSN07tzZcb1z584cPqxpSSJtUqAadrRUKsREpFXwbRfIrm63AtAh+UXsFTopWcxVWFhITEwMCxYsqPX2ZcuWMXPmTObMmUNycjIxMTGMGTOGrKwsx5jY2FgGDBhQ43LkyBFnPQ0RcXVaS6zFcjM7gIhIU4m69mHy579OD3s6W9csZdAVt5odSdqwsWPHMnbs2Dpvf/7557nrrruYNq1yWu3ChQv56KOPWLRoEbNmzQIgJSXlnB47PDy82hGww4cPM2zYsDrHl5SUUFLyc6ObvLy8c3pcEWmB2nev/FdTE1scHRETkVYjoH0wqRGTAfBLnI9ht5ucSKR2paWlJCUlkZCQ4NhmtVpJSEhgw4YN573/YcOGkZqayuHDhykoKOCTTz5hzJgxdY6fN28eAQEBjkuXLl3OO4OItBCOI2KamtjSqBATkVal74Q/cNrwpHf5XravX252HJFaZWdnU1FRQWhoaLXtoaGhHDt2rMH7SUhIYNKkSXz88cdEREQ4ijg3Nzeee+45Ro8eTWxsLA8++CAdOnSocz+zZ88mNzfXcTl06NC5PTERaXmqzhHLOwzlpeZmkWo0NVFEWpWgjp3ZGHYdF2a+jdu3z8Oo682OJNJsvvjiizpvu+aaa7jmmmsatB9PT088PT2bKpaItCR+HcHNC8qLIS8Dgi4wO5H8REfERKTV6TlhNqWGG1Flqezc8InZcURqCA4OxmazkZmZWW17ZmYmYWFhJqUSkVbJYvl5eqLOE2tRVIiJSKsTEt6drcFXA1Dx5dMmpxGpycPDgyFDhrBmzRrHNrvdzpo1axg+fLiJyUSkVXK0sFch1pKoEBORVqnL+EcpN6xElyTzQ/KXZseRNqigoICUlBRH58O0tDRSUlI4eLDyhPmZM2fyyiuv8Prrr7Nr1y7uvvtuCgsLHV0URUSajBp2tEg6R0xEWqXw7n3Z3P4KhuZ8SuEXf4PBo8yOJG3Mli1bGD16tOP6zJkzAZgyZQpLlixh8uTJHD9+nMcff5xjx44RGxvLp59+WqOBh4jIeWv/0xExTU1sUVSIiUirFXrVbOxvfsag09/x4/ZN9IyONzuStCGjRo3CMIx6x0yfPp3p06c7KZGItFmOqYk6ItaSaGqiiLRaXfvEstV/FACnVs8zN4yIiIhZHFMTdUSsJVEhJiKtWvsxswEYnPclB39IMTeMiIiIGdp3r/y3IBPKikyNIj9TISYirdoFA+LZ6jMCq8Xg2Ed/NTuOiIiI83m3Bw+/yp9ztGB7S6FCTERaPd+ERwAYnPMZRw7sMTmNiIiIk1ksamHfAqkQE5FWr8/gUWz3HIybxc6hD+eaHUdERMT52qsQa2nUNVFE2gTbqD/AZzcxKHsVWYcP0LFzd7Mjibg0u91OaWmp2THEidzd3bHZbGbHkHNV1bBDLexbDBViItImRA0fy661/Yks28H+lfPoePfLZkcScVmlpaWkpaVht9vNjiJOFhgYSFhYGBaLxewo0lhqYd/iqBATkTaj7KIH4cvbiTn2P05mPU5Qx85mRxJxOYZhcPToUWw2G126dMFq1VkObYFhGJw+fZqsrCwAOnXqZHIiaTS1sG9xVIiJSJsRfcl17P1mHr3L95Ky4mmG//YFsyOJuJzy8nJOnz5NeHg4Pj4+ZscRJ/L29gYgKyuLjh07apqiq6k6R0xTE1sMfY0lIm2GxWqlYNgMAAYcXkbuyWxzA4m4oIqKCgA8PDxMTiJmqCq+y8rKTE4ijVZ1RKzoJJTkm5tFABViItLGxFx2M2nWbrSzFLHzg2fMjiPisnSOUNuk192FeQWAV2DlzzpPrEVQISYibYrVZuPk4PsAiEz/L4X5OeYGEhERcZb2atjRkqgQE5E2J/bKaRyyhBNIAds/+LvZcURERJxDLexbFJcoxL788kssFkutl82bNwPwxBNP1Hq7r69vvfvevHkzl112GYGBgbRv354xY8bw/fffO+NpiYhJbG5uHB14NwC99i2h+HSByYlERMyRk5NDXFwcsbGxDBgwgFdeecXsSNKcArWoc0viEoXYiBEjOHr0aLXLnXfeSY8ePYiLiwPgoYceqjEmKiqKSZMm1bnfgoICrrzySrp27cqmTZv45ptvaNeuHWPGjNFJqCKt3KBxv+MYIQSTQ8rKl8yOIyJiinbt2rF+/XpSUlLYtGkTc+fO5cSJE2bHkuaitcRaFJcoxDw8PAgLC3NcOnTowAcffMC0adMcJ436+flVG5OZmcnOnTu544476tzv7t27OXnyJE899RR9+/alf//+zJkzh8zMTNLT9U2BSGvm7uFJeuRdAHTf/QqlJcUmJxIRZ5g1axaenp7ccsstZkdpEWw2m6MTYklJCYZhYBiGyamk2aiFfYviEoXYL61cuZITJ04wbdq0Ose8+uqr9OnTh4svvrjOMX379qVDhw689tprlJaWUlRUxGuvvUZkZCTdu3dvhuQi0pLEXDOdbAIJI5uUj142O46IOMHs2bN57rnnWLp0Kfv27TM7Tr3Wr1/P+PHjCQ8Px2KxsGLFilrHLViwgO7du+Pl5UV8fDyJiYmNepycnBxiYmKIiIjg4YcfJjg4uAnSS4ukI2ItiksWYq+99hpjxowhIiKi1tuLi4t588036z0aBpWH47/88kv++9//4u3tjZ+fH59++imffPIJbm51r3VdUlJCXl5etYuIuB4vb19+7FX5hU749n9RXlZqciIRaW4BAQHccccdWK1Wtm/fbnacehUWFhITE8OCBQvqHLNs2TJmzpzJnDlzSE5OJiYmhjFjxpCVleUYU3X+1y8vR44cASAwMJDvv/+etLQ03nrrLTIzM5v9uYlJArtU/luSC0WnzM0i5hZis2bNqrMJR9Vl9+7d1e6TkZHBZ599Vm+RtXz5cvLz85kyZUq9j19UVMQdd9zBRRddxMaNG/n2228ZMGAA48aNo6ioqM77zZs3j4CAAMelS5cujXviItJiRF87g1O0I8I4Ssqni82OIyJOUF5ejo+PD6mpqWZHqdfYsWP585//zHXXXVfnmOeff5677rqLadOmERUVxcKFC/Hx8WHRokWOMSkpKaSmpta4hIeHV9tXaGgoMTExfP311832nMRkHr7gG1L5s6Ynms7UQuzBBx9k165d9V4uuOCCavdZvHgxHTp04Jprrqlzv6+++ipXX301oaGh9T7+W2+9xYEDB1i8eDFDhw7lwgsv5K233iItLY0PPvigzvvNnj2b3Nxcx+XQoUONe+Ii0mL4+AWyp9uvAeiw9SXsFRUmJxJpO47mFvHdj9kcza37y8/m8Kc//YmCggKnFWJz587Fz8+v3svBg42fKlZaWkpSUhIJCQmObVarlYSEBDZs2NCgfWRmZpKfnw9Abm4u69evp2/fvo3OIi6kqoW9piearu75d04QEhJCSEhIg8cbhsHixYu57bbbcHd3r3VMWloa69atY+XKlWfd3+nTp7FardVWia+6brfb67yfp6cnnp6eDc4tIi1b1HUPkz//dXrYD5L8xVsMHvMbsyOJuAzDMCgqa/wXGO8nZTBn5Q7sBlgt8OQ1/bl+SO2nHNTF291W7TO8IZKSkli4cCHjxo1zWiH2+9//nhtvvLHeMb88OtUQ2dnZVFRU1PjiOTQ0tMaMorqkp6fz29/+1tGk47777iM6OrrRWcSFBHaDw0lqYd8CmFqINdbatWtJS0vjzjvvrHPMokWL6NSpE2PHjq1x2/Lly5k9e7bjzenyyy/n4Ycf5t577+W+++7Dbrfz17/+FTc3N0aPHt1sz0NEWhb/wGA2dp7MhYeX0C5xPsblv8ZidclTaEWcrqisgqjHPzuvfdgNeOyDHTz2wY5G3W/nU2Pw8Wj4nzJ2u53f/e53TJ8+nfj4eG699VbKysrq/HK3NkeOHOHhhx/mzTffbPB9goKCCAoKavB4Zxo2bBgpKSlmxxBnaq+GHS2FS/2l8dprrzFixAj69etX6+12u50lS5YwdepUbDZbjdtzc3PZs2eP43q/fv348MMP2bZtG8OHD+fiiy/myJEjfPrpp3Tq1KnZnoeItDx9r32E04YnvSv2se2r/5kdR0SawYsvvkh2djZPPfUU0dHRlJWVNfjIUZXw8PBGFWHQfFMTg4ODsdlsNZprZGZmEhYW1uj9SRtRNTVR54iZzqWOiL311lv13m61Wus9X2vq1KlMnTq12rbLL7+cyy+/vCniiYgLax8SzsawiVyYuRSP757DGDlRR8VEGsDb3cbOp8Y06j7HcotJeP4r7GcsV2W1wBczRxIW4NWox26ow4cP89hjj7F06VJ8fX3p3bs3np6epKamEh0dzYEDB5gwYQIDBgwgMTGRhIQExowZw7x58ygsLGT58uX07t2bAwcOcMMNN/Dee+8xYcIEYmNjSUxMZODAgbz99tu1TpVsrqmJHh4eDBkyhDVr1nDttdcClV9Kr1mzhunTpzd6f9JGOFrYqxAzm0sVYiIizannhFmUvvwukWU72bHxU/qPuMrsSCItnsViadT0QIALQvyYNzGaR/+XSoVhYLNYmDtxABeE+DVTSrj//vsZO3Ys48aNA8DNzY3IyMhq54nt2rWLd955h169ejFgwAD8/PzYtGkTL7/8Mi+99BIvvPBCtX3u2rWLpUuXEhkZyejRo/nmm29qXb/0XKcmFhQUVFvrLC0tjZSUFIKCgujatfKoxsyZM5kyZQpxcXEMGzaM+fPnU1hYWO9aq9LGnbmWmGFAI8+zlKajQkxE5Cch4d3ZFDye+BPLsX/1NKgQE2k2k4d25ZI+IRzIPk33YB86BXg322OtWrWKtWvXsmvXrmrbo6OjqxViffv2dXQMjIyMdHQjjI6O5uOPP66x3759+xIVFQXAoEGDOHDgQK2F2LnasmVLtXPWZ86cCcCUKVNYsmQJAJMnT+b48eM8/vjjHDt2jNjYWD799NOzdo6WNiywC2CBstNQmA1+DW+cJ01LhZiIyBm6XjObskUriS7Zyu4ta+kXd6nZkURarU4B3s1agFW5+uqrOXWq5uK1b7zxRrXrZ3ZEtlqtjutWq5WKWpa2OHO8zWardcz5GDVqFIZhnHXc9OnTNRVRGs7NE9p1gvwjlUfFVIiZRidAiIicoVO3vqS0vwKA4jVPm5xGRESkGTjWEjtgaoy2ToWYiMgvhI2bjd2wEFu0gX3bG7YoqoiIiMuoamGvzomm0tREEZFf6NI7hiT/UQzJX0fuZ3+F6A/MjiQizax79+5s2bLFcf29995z/HzhhReyatWqGuPOHP/ss886KalIE3AcEdNaYmbSETERkVoEXTkbgEH5X5G+Z6vJaURERJqQWti3CCrERERq0aN/PFt9RmC1GGR9PM/sOCJ1uu6662jfvj033HBDte2HDh1i1KhRREVFMXDgQN59912TEopIi9P+jBb2YhoVYiIidfBNmAXAoJzPObx/t8lpRGr3wAMP1Oj+B5XrZM2fP5+dO3eyevVqZsyYQWFhoQkJRaTFOXNqot1ubpY2TIWYiEgd+gweyXavIbhZ7GSsmmt2HJFajRo1inbt2tXY3qlTJ2JjYwEICwsjODiYkydPOjmdiLRI/hFgsUFFKRQcMztNm6VCTESkHm4jHwZg0ImPyDy83+Q04mrWr1/P+PHjCQ8Px2KxsGLFihpjFixYQPfu3fHy8iI+Pp7ExMQmz5GUlERFRQVdunRp8n2LiAuyuYF/58qfNT3RNCrERETqETl8LDs9BuBhKSftg7+aHUdcTGFhITExMSxYsKDW25ctW8bMmTOZM2cOycnJxMTEMGbMGLKyshxjYmNjGTBgQI3LkSNHGpTh5MmT3Hbbbfz73/9ukuckIq2EWtibTu3rRUTOouKiB2HdNGIyl3Mi83E6hEaYHUlcxNixYxk7dmydtz///PPcddddTJs2DYCFCxfy0UcfsWjRImbNqjxHMSUl5Zwfv6SkhGuvvZZZs2YxYsSIeseVlJQ4rufl5Z3zY4qIiwjsBnytI2Im0hExEZGzGHDxtex16423pZQfPnja7DjSSpSWlpKUlERCQoJjm9VqJSEhgQ0bzn8hccMwmDp1Kpdeeim/+c1v6h07b948AgICHBdNYRRpAxwNOw6YGqMtUyEmInIWFquVwvj/AyD68Dvknsw6yz1Ezi47O5uKigpCQ0OrbQ8NDeXYsYafPJ+QkMCkSZP4+OOPiYiIcBRx3377LcuWLWPFihXExsYSGxvL9u3ba93H7Nmzyc3NdVwOHTp07k9MRFyDpiaaTlMTRUQaYOClN5G24W/0sKezYcUzDL/9GbMjiQDwxRdf1Lr9V7/6FfYGtqX29PTE09OzKWOJSEt3Zgt7MYWOiImINIDVZuPkkPsAiDr4X75f8zaZGT+amikz40dSv/1QOVxUcHAwNpuNzMzMatszMzMJCwszKZWItBmBPx0Ry82AinJzs7RROiLWhAoLC7HZbDW222w2vLy8qo2ri9Vqxdvb+5zGnj59GsMwah1rsVjw8fE5p7FFRUX1fqvq6+t7TmOLi4upqKhokrE+Pj5YLBag8qTz8vK631AaM9bb2xurtfL7itLSUsrKyppkrJeXl+N3pTFjy8rKKC0trXOsp6cnbm5ujR5bXl5e7UT9X/Lw8MDd3b3RYysqKiguLq5zrLu7Ox4eHo0ea7fbKSoqapKxbm5ujiMBhmFw+vTpOsdGjrqFE5v/Hx3IZeD635L/hYWvBjxK3LXTa4xtzP/35/Iekfj+fIZsewK/MjsVRu05nPEekfj+fKKS5uCHUWeOs71HtNVFhj08PBgyZAhr1qzh2muvBSp/X9esWcP06TV/p0SaS1paGrfffjuZmZnYbDY2btxY7f9baaXadQKrO9jLIP/Iz0fIxHkMOW+5ubkGUOflqquuqjbex8enzrEjR46sNjY4OLjOsXFxcdXGduvWrc6xUVFR1cZGRUXVObZbt27VxsbFxdU5Njg4uNrYkSNH1jnWx8en2tirrrqq3v9uZ7rhhhvqHVtQUOAYO2XKlHrHZmVlOcbec8899Y5NS0tzjH3ooYfqHZuamuoYO2fOnHrHJiYmOsY+/fTT9Y5dt26dY+xLL71U79hVq1Y5xi5evLjese+8845j7DvvvFPv2MWLFzvGrlq1qt6xL730kmPsunXr6h379NNPO8YmJibWO3bOnDmOsampqfWOfeihhxxj09LS6h17zz33OMZmZWXVO/bGGyYaFY8HGMYcf6Ngdrt6x146sLOR+Nz1jkt9Yy+KDKs21svDVufYwT2DjaS/XWXYH/c3jDn+RrCPpc6xkV3aV9tvp/Z1v/f0CG1XbWyP0LqfX6f2Pkbic9c7csSFW+sc25j3iNzcXKO1yc/PN7Zu3Wps3brVAIznn3/e2Lp1q5Genm4YhmG8/fbbhqenp7FkyRJj586dxm9/+1sjMDDQOHbsmKm5qz7XantNioqKjJ07dxpFRUUmJJPmcMkllxjr1683DMMwTpw4YZSVldU5Vq9/K/NCrGHM8TeM/evNTtKq1PceeiYdERMRaaDiwhysFqNBY4PKMxma93mDxgaUZ1cbazXqPvrbrvwUg09/A5az79e3Irfafj3sdR8Z9LYXVhvrba/7KJWHvejnsQ3I0ZZt2bKF0aNHO67PnDkTgClTprBkyRImT57M8ePHefzxxzl27BixsbF8+umnNRp4SNOZNWsWf//737n++ut56623zI5juh07duDu7s7FF18MQFBQkMmJxKkCu8HJ/ZCTDlxsdpo2x2IYdcw9kQbLy8sjICCAI0eO4O/vX+N2TU2sfaymJmpqoqtNTTxxLJ3Ob4zAZjEqx5aB3bCwOeI3WL0Cqo21Wi14erg7rhcV1/1aNGasxWrBo6KQ+EOLsFqgsLTy/+PaclisFrzO2G9xSSl1veNbLODl6dGosfaiHOIPLaKk3MD+09hyw8qJaV8T2vkCx/izvUfk5eURHh5Obm5ure+h4nxVn2u1vSbFxcWkpaXRo0ePap9triI3N5f//Oc/3Hfffezdu5devXqZHalO69ev55lnniEpKYmjR4+yfPlyxzTWMy1YsIBnnnmGY8eOERMTw4svvsiwYcMa9BgrVqxgyZIlVFRUcPjwYW644QYeffTROse7+usvv7Dyfkh+HUY+AqPrft2lcep7Dz2Tjog1IV9f3wbNqW7MvOvGjD2zeGrKsWcWe005tjFv4I0Z25juX40Z6+Hh4fjj3qyx7u7ujiKnKce6ubk5irKmHGuz2Rr8O9yYsVartVnGWiyWesf69owiceATDN72JG4WO57uVpIHzuHS62c0aP9NKfH9bgze9iS+HnbKDfNzuFkqc+wYOIdhfaLrHF/be0R9X7KINLWAgADuuOMOHnjgAbZv396iC7HCwkJiYmK4/fbbmThxYq1jli1bxsyZM1m4cCHx8fHMnz+fMWPGsGfPHjp27AhAbGxsrV86rl69mvLycr7++mtSUlLo2LEjV155JUOHDuXyyy9v1ucmLYRa2JtKhZiISCMMu34GmfHjyU7fTXC3fgyL6KkcLSCHSGOUl5fj4+NDamoq1113ndlx6jR27FjGjh1b75jnn3+eu+66i2nTpgGwcOFCPvroIxYtWsSsWbMASElJqfP+nTt3Ji4uzrGI91VXXUVKSooKsbaiqnOiWtibQu3rRUQaKTSiJ/0vGkeoyUWHcojLyz0Maesr/3WiP/3pTxQUFJCamuqUx5s7dy5+fn71Xg4ebPwfwqWlpSQlJZGQkODYZrVaSUhIcCzsfTZDhw4lKyuLU6dOYbfbWb9+PZGRkY3OIi7KUYjpiJgZdERMREREzp1hQFnd51bWKeUt+OQPYNjBYoWxT0PsLY3bh7tP5UmLjZCUlMTChQsZN26c0wqx3//+99x44431jgkPD2/0frOzs6moqKjR3CU0NJTdu3c3aB9ubm7MnTuXSy65BMMwuOKKK7j66qsbnUVcVNXUxLwjUF4CblrY3ZlUiImIiMi5KzsNcxtfRFRj2OHjhyovjfHoEfBo+LnUdrud3/3ud0yfPp34+HhuvfVWysrKGnw+LcCRI0d4+OGHefPNNxt8n6CgoBbdjbAhUyCllfINATdvKC+qXNi5g2Y2OJOmJoqIiEib8OKLL5Kdnc1TTz1FdHQ0ZWVlDT5yVCU8PLxRRRg039TE4OBgbDYbmZmZ1bZnZmYSFhbW6P1JG2Sx/LyQs6YnOp2OiImIiMi5c/epPDLVGHlHYMGwyiNhVSw2uHcT+Dfi6Jp7wzsAHz58mMcee4ylS5fi6+tL79698fT0JDU1lejoaA4cOMCECRMYMGAAiYmJJCQkMGbMGObNm0dhYSHLly+nd+/eHDhwgBtuuIH33nuPCRMmEBsbS2JiIgMHDuTtt992LI9ypuaamujh4cGQIUNYs2aNo6293W5nzZo1TJ8+vdH7kzYqsCtk71HDDhOoEBMREZFzZ7E0anogAMG9YfwL8OEMMCoqi7Dx8yu3N5P777+fsWPHMm7cOKDy3KjIyMhq54nt2rWLd955h169ejFgwAD8/PzYtGkTL7/8Mi+99BIvvPBCtX3u2rWLpUuXEhkZyejRo/nmm28cCyOf6VynJhYUFLBv3z7H9bS0NFJSUggKCqJr18qjGDNnzmTKlCnExcUxbNgw5s+fT2FhoaOLoshZqYW9aVSIiYiIiPMNvg16XgYn90PQBRDQudkeatWqVaxdu5Zdu3ZV2x4dHV2tEOvbty99+/YFIDIy0tGNMDo6mo8//rjGfvv27UtUVBQAgwYN4sCBA7UWYudqy5YtjB492nF95syZAEyZMoUlS5YAMHnyZI4fP87jjz/OsWPHiI2N5dNPP63RwEOkTuqcaBoVYiIiImKOgM7NWoBVufrqqzl16lSN7W+88Ua1656eP3eMs1qtjutWq7XWhcfPHG+z2Zp8cfJRo0ZhGMZZx02fPl1TEeXcOc4R09REZ1OzDhERERGRtkpTE02jQkxEREREpK2qmppYmAUnfjQ3i0mLvJuVw2I05Ji31CsvL4+AgACOHDlCWFiYo2NSaWkpZWVluLm5VZu+UFhYCIC3tzdWa2UtXFZWRmlpKTabDS8vr3Mae/r0aQzDwMvLC5vNBkB5eTklJSVYrVa8vb3PaWxRURF2ux1PT0/c3Cpns1ZUVFBcXNyosRaLBR+fnztcFRcXU1FRgYeHh2MNl8aMtdvtFBUVAeDr+/OJ4iUlJZSXl+Pu7o6Hh0ejxxqGwenTlYuT+vj41Hg9GzO2Ia99U/ye1PZ6NsXvSdXreb6/J798Pc/396Su1/N8f0/OfD3P9/ekrtfzXH9PWvN7xKlTpwgKCiI3Nxd/f3/EfFWfa7W9JsXFxaSlpdGjR49qv1/SNuj1b4WSXocP7//pigXibocLRjk/x/4vYcsiwGg5OSzWysZCg29r1C7qew+txpDzlpuba1S+WhhZWVmO7X/+858NwLjzzjurjffx8TEAIy0tzbHt73//uwEYt9xyS7WxwcHBBmCkpqY6tv373/82AGPChAnVxnbr1s0AjMTERMe2//73vwZgJCQkVBsbFRVlAMa6desc25YvX24AxogRI6qNjYuLMwBj1apVjm2rV682ACMmJqba2JEjRxqA8c477zi2ffPNNwZg9OrVq9rYq666ygCMxYsXO7Zt3brVAIzw8PBqY2+44QYDMF566SXHth9++MEAjICAgGpjp0yZYgDG008/7diWkZFhAIabm1u1sffcc48BGHPmzHFsO3XqlOP1LC0tdWx/6KGHDMB46KGHHNtKS0sdY0+dOuXYPmfOHAMw7rnnnmqP5+bmZgBGRkaGY9vTTz9tAMaUKVOqjQ0ICDAA44cffnBse+mllwzAuOGGG6qNDQ8PNwBj69atjm2LFy82AOOqq66qNrZXr14GYHzzzTeObe+8844BGCNHjqw2NiYmxgCM1atXO7atWrXKAIy4uLhqY0eMGGEAxvLlyx3b1q1bZwBGVFRUtbEJCQkGYPz3v/91bEtMTDQAo1u3btXGTpgwwQCMf//7345tqampBmAEBwdXG3vLLbcYgPH3v//dsS0tLc0ADB8fn2pj77zzTgMw/vznPzu2ZWVlOV7PMz3wwAMGYDz66KOObQUFBY6xBQUFju2PPvqoARgPPPBAtX3oPaJSbe8Rn332mQEYubm5hrQMVZ9rtb0mRUVFxs6dO42ioiITkonZ9Pq3MjkZhvFEoGHM8delrssT7Sv/OzVCfe+hZ1KzDhERERGRtujkj9XX86sSEgleAc7LUZwLx3fV3N4SchgVld1dm6GxkKYmNgFNTdTUxLrGamqipib+8vXU1ERNTXQFmpooddHr38rkHob5A2ourj5ju1M6mrbWHA2dmqhCrAk0eB6oiIjUoPfQlkeFmNRFr38rlPxGzcXVG3lOlHJU19DPNU1NFBERERFpq5y4uLpyVKdCTERERBpNE2raJr3urZSTFldXjuq0jpiIiIg0WNU5g6WlpSYnETNUnRtbdR6uiJw7HRETERGRBnNzc8PHx4fjx4/j7u7uaBIjrVtVg6KsrCwCAwMdBbmInDsVYiIiItJgFouFTp06kZaWRnp6utlxxMkCAwMJCwszO4ZIq6BCTERERBrFw8OD3r17a3piG+Pu7q4jYSJNSIWYiIiINJrValX7chGR86CJ3SIiIiIiIk6mQkxERERERMTJVIiJiIiIiIg4mc4RawJVixvm5eWZnERExPVUvXdqodiWQ59rIiLnrqGfayrEmkB+fj4AXbp0MTmJiIjrys/PJyAgwOwYgj7XRESawtk+1yyGvoI8b3a7nSNHjtCuXTssFkuj7puXl0eXLl04dOgQ/v7+zZRQOZRDOZSj5eYwDIP8/HzCw8O1OHALoc815VAO5VCO5v9c0xGxJmC1WomIiDivffj7+5v6C6ccyqEcymFmDh0Ja1n0uaYcyqEcytH8n2v66lFERERERMTJVIiJiIiIiIg4mQoxk3l6ejJnzhw8PT2VQzmUQzmUQ1xeS/l9UA7lUA7laOk51KxDRERERETEyXRETERERERExMlUiImIiIiIiDiZCjEREREREREnUyEmIiIiIiLiZCrETDJv3jyGDh1Ku3bt6NixI9deey179uwxNdNf//pXLBYLM2bMMOXxDx8+zK233kqHDh3w9vYmOjqaLVu2ODVDRUUFjz32GD169MDb25uePXvy//7f/6O5e9qsX7+e8ePHEx4ejsViYcWKFdVuNwyDxx9/nE6dOuHt7U1CQgJ79+51ao6ysjIeeeQRoqOj8fX1JTw8nNtuu40jR444Nccv/f73v8disTB//nxTcuzatYtrrrmGgIAAfH19GTp0KAcPHnRqjoKCAqZPn05ERATe3t5ERUWxcOHCJs0ADXvfKi4u5t5776VDhw74+flx/fXXk5mZ2eRZpOXR51pN+lzT51pDcvySPtfazueaCjGTfPXVV9x7771s3LiRzz//nLKyMq644goKCwtNybN582ZefvllBg4caMrjnzp1iosuugh3d3c++eQTdu7cyXPPPUf79u2dmuNvf/sb//rXv3jppZfYtWsXf/vb33j66ad58cUXm/VxCwsLiYmJYcGCBbXe/vTTT/OPf/yDhQsXsmnTJnx9fRkzZgzFxcVOy3H69GmSk5N57LHHSE5O5n//+x979uzhmmuuadIMZ8txpuXLl7Nx40bCw8ObPENDcvz444/86le/ol+/fnz55Zds27aNxx57DC8vL6fmmDlzJp9++in//e9/2bVrFzNmzGD69OmsXLmySXM05H3r//7v//jwww959913+eqrrzhy5AgTJ05s0hzSMulzrTp9rulzraE5zqTPtUpt5nPNkBYhKyvLAIyvvvrK6Y+dn59v9O7d2/j888+NkSNHGg888IDTMzzyyCPGr371K6c/7i+NGzfOuP3226ttmzhxovHrX//aaRkAY/ny5Y7rdrvdCAsLM5555hnHtpycHMPT09NYunSp03LUJjEx0QCM9PR0p+fIyMgwOnfubKSmphrdunUz/v73vzdbhrpyTJ482bj11lub9XEbkqN///7GU089VW3b4MGDjT/+8Y/NmuWX71s5OTmGu7u78e677zrG7Nq1ywCMDRs2NGsWaXn0uabPtSr6XGtYDn2u/aytfK7piFgLkZubC0BQUJDTH/vee+9l3LhxJCQkOP2xq6xcuZK4uDgmTZpEx44dGTRoEK+88orTc4wYMYI1a9bwww8/APD999/zzTffMHbsWKdnqZKWlsaxY8eqvT4BAQHEx8ezYcMG03JB5e+txWIhMDDQqY9rt9v5zW9+w8MPP0z//v2d+thnZvjoo4/o06cPY8aMoWPHjsTHx9c73aS5jBgxgpUrV3L48GEMw2DdunX88MMPXHHFFc36uL9830pKSqKsrKza72q/fv3o2rWr6b+r4nz6XNPnWl30uVaTPteqayufayrEWgC73c6MGTO46KKLGDBggFMf++233yY5OZl58+Y59XF/af/+/fzrX/+id+/efPbZZ9x9993cf//9vP76607NMWvWLG666Sb69euHu7s7gwYNYsaMGfz61792ao4zHTt2DIDQ0NBq20NDQx23maG4uJhHHnmEm2++GX9/f6c+9t/+9jfc3Ny4//77nfq4Z8rKyqKgoIC//vWvXHnllaxevZrrrruOiRMn8tVXXzk1y4svvkhUVBQRERF4eHhw5ZVXsmDBAi655JJme8za3reOHTuGh4dHjT9gzP5dFefT55o+1+qjz7Wa9LlWXVv5XHM77z3Iebv33ntJTU3lm2++cerjHjp0iAceeIDPP/+8yef+NpbdbicuLo65c+cCMGjQIFJTU1m4cCFTpkxxWo533nmHN998k7feeov+/fuTkpLCjBkzCA8Pd2qOlq6srIwbb7wRwzD417/+5dTHTkpK4oUXXiA5ORmLxeLUxz6T3W4HYMKECfzf//0fALGxsXz33XcsXLiQkSNHOi3Liy++yMaNG1m5ciXdunVj/fr13HvvvYSHhzfbEQGz3rfENehzTZ9rrkafa/pcM+N9S0fETDZ9+nRWrVrFunXriIiIcOpjJyUlkZWVxeDBg3Fzc8PNzY2vvvqKf/zjH7i5uVFRUeG0LJ06dSIqKqratsjIyCbv0nM2Dz/8sOPbw+joaH7zm9/wf//3f6Z+sxoWFgZQo0NPZmam4zZnqvqwSk9P5/PPP3f6t4Zff/01WVlZdO3a1fF7m56ezoMPPkj37t2dliM4OBg3NzfTf2+Liop49NFHef755xk/fjwDBw5k+vTpTJ48mWeffbZZHrOu962wsDBKS0vJycmpNt6s31Uxhz7XKulzrW76XKtOn2vVtaXPNRViJjEMg+nTp7N8+XLWrl1Ljx49nJ7hsssuY/v27aSkpDgucXFx/PrXvyYlJQWbzea0LBdddFGNdqE//PAD3bp1c1oGqOygZLVW/9/CZrM5viUyQ48ePQgLC2PNmjWObXl5eWzatInhw4c7NUvVh9XevXv54osv6NChg1MfH+A3v/kN27Ztq/Z7Gx4ezsMPP8xnn33mtBweHh4MHTrU9N/bsrIyysrKnPJ7e7b3rSFDhuDu7l7td3XPnj0cPHjQ6b+r8v/bu/egqMr/D+DvDUUWdgUWZQFl2UUUwVARGxQNr3mZhqRMVjNEYcpxTaEMbVSM8hreSxlDBdQ0wnGQAVPRGWAcwtsoWkioaEkjSprmJZRYn+8f/Tg/N64iHnR6v2Z2pnN79nOejvv2OfvsUX7MNUvMtYYx1ywx1yz9l3KNUxPbyMyZM7Fr1y5kZmZCrVZL80zt7e2hVCplqUGtVteZu29nZwcnJyfZ5/R/+OGHCAoKwrJlyxAWFobjx48jKSkJSUlJstYREhKCpUuXQqfToVevXjh9+jTWrFmDyMjIZ/q+9+7dw8WLF6Xly5cvo6ioCBqNBjqdDjExMViyZAm6d+8Og8GAuLg4uLm5ITQ0VLY6XF1d8fbbb+PUqVPIzs6G2WyWrluNRgNra2tZ6tDpdHWCsn379nBxcYG3t3er1dCcOmJjY2E0GhEcHIxhw4bhwIEDyMrKQl5enqx1DBkyBLGxsVAqlfDw8EB+fj62b9+ONWvWtGodTX1u2dvbIyoqCh999BE0Gg06duyIWbNmYeDAgRgwYECr1kLPH+aaJeYac625dTDX/sO59tTPXaQWAVDvKyUlpU3raqvH/AohRFZWlnj55ZdFhw4dRM+ePUVSUpLsNdy5c0dER0cLnU4nbGxshKenp1iwYIF4+PDhM33f3Nzceq+HiIgIIcQ/j/qNi4sTWq1WdOjQQYwYMUKUlpbKWsfly5cbvG5zc3Nlq6M+z+oxv82pY+vWrcLLy0vY2NiIPn36iL1798peR0VFhZg6dapwc3MTNjY2wtvbW6xevVo8evSoVetozudWVVWVMJlMwtHRUdja2oo333xTVFRUtGod9HxirtXFXGOuNaeO+jDX/hu5pvi/IoiIiIiIiEgm/I0YERERERGRzDgQIyIiIiIikhkHYkRERERERDLjQIyIiIiIiEhmHIgRERERERHJjAMxIiIiIiIimXEgRkREREREJDMOxOiFkpqaCgcHh7Yu44Wj1+uxbt26NnnvoUOHIiYm5omOiY+PR9++faXlqVOnIjQ0tFXrehbasp+J6MXEXGsZ5po8mGvPFgdi9EIxGo04f/58W5fRbHl5eVAoFHB0dMSDBw8stp04cQIKhQIKhaLO/rUvrVaL8ePH49KlS9I+Z86cwRtvvAFnZ2fY2NhAr9fDaDSisrJStvOS2/r165GamtrWZTTpxIkTeP/999u6DCJ6gTDXmGvPM+bas8WBGL1QlEolnJ2d27qMJ6ZWq5GRkWGxbuvWrdDpdPXuX1paiqtXr2L37t0oLi5GSEgIzGYzfv/9d4wYMQIajQYHDx5ESUkJUlJS4Obmhvv378txKm3C3t7+hbhj3LlzZ9ja2rZ1GUT0AmGuMdeeZ8y1Z4sDMWqRoUOHYtasWYiJiYGjoyO0Wi02b96M+/fvY9q0aVCr1fDy8sL+/fulY8xmM6KiomAwGKBUKuHt7Y3169dL2x88eIBevXpZ3HkpKyuDWq1GcnIygLpTOGq/6k9OToZOp4NKpYLJZILZbEZCQgJcXFzg7OyMpUuXSsf88ssvUCgUKCoqktbdvn0bCoUCeXl5AP7/Dt7Bgwfh7+8PpVKJ4cOHo7KyEvv374ePjw86duyId955B3/99VeT/RURESGdAwBUVVUhLS0NERER9e7v7OwMV1dXBAcHY9GiRTh37hwuXryIgoIC/Pnnn9iyZQv8/f1hMBgwbNgwrF27FgaDodEa7t69i0mTJsHOzg5dunTBxo0bLbZfuXIF48aNg0qlQseOHREWFobr16/X6esdO3ZAr9fD3t4eEydOxN27d6V97t+/jylTpkClUsHV1RWrV69usm8AYMWKFdBqtVCr1YiKiqpzl/XfUzhacv0BwE8//YSxY8dCpVJBq9UiPDwcN27csGh39uzZmDt3LjQaDVxcXBAfHy9tF0IgPj4eOp0OHTp0gJubG2bPni1t//cUjtboUyKSB3ONucZcY67JjQMxarFt27ahU6dOOH78OGbNmoUZM2ZgwoQJCAoKwqlTpzBq1CiEh4dLH+iPHj1C165dsXv3bpw7dw6LFi3C/PnzkZ6eDgCwsbHBzp07sW3bNmRmZsJsNuPdd9/Fa6+9hsjIyAbrKCsrw/79+3HgwAF8++232Lp1K15//XX89ttvyM/PxxdffIGFCxfi2LFjT3yO8fHx2LBhA3744QeUl5cjLCwM69atw65du7Bv3z7k5OTgq6++arKd8PBwHDlyBFeuXAEA7NmzB3q9Hv369WvyWKVSCQCorq6Gi4sLampqkJGRASHEE53LypUr0adPH5w+fRqffPIJoqOjcejQIQD//L8ZN24c/vjjD+Tn5+PQoUO4dOkSjEajRRtlZWXYu3cvsrOzkZ2djfz8fKxYsULaHhsbi/z8fGRmZiInJwd5eXk4depUo3Wlp6cjPj4ey5Ytw8mTJ+Hq6orExMQmz+dJr7/bt29j+PDh8Pf3x8mTJ3HgwAFcv34dYWFhddq1s7PDsWPHkJCQgM8//1zqpz179mDt2rX4+uuvceHCBezduxd+fn711tdafUpE8mGuMdeYa8w1WQmiFhgyZIgYPHiwtFxTUyPs7OxEeHi4tK6iokIAEIWFhQ22M3PmTDF+/HiLdQkJCaJTp07igw8+EK6uruLGjRvStpSUFGFvby8tf/rpp8LW1lbcuXNHWjd69Gih1+uF2WyW1nl7e4vly5cLIYS4fPmyACBOnz4tbb9165YAIHJzc4UQQuTm5goA4vDhw9I+y5cvFwBEWVmZtG769Oli9OjRDZ5fbTu3bt0SoaGh4rPPPhNCCDFs2DCxfv16kZGRIR7/Y/j4/kIIcfXqVREUFCS6dOkiHj58KIQQYv78+aJdu3ZCo9GIMWPGiISEBHHt2rUGaxBCCA8PDzFmzBiLdUajUYwdO1YIIUROTo6wsrISV65ckbYXFxcLAOL48eNCiPr7OjY2VgQGBgohhLh7966wtrYW6enp0vabN28KpVIpoqOjG6xt4MCBwmQyWawLDAwUffr0kZYjIiLEuHHjpOWWXH+LFy8Wo0aNsnif8vJyAUCUlpbW264QQrzyyiti3rx5QgghVq9eLXr06CGqq6vrPRcPDw+xdu1aIUTr9CkRyYe59g/mGnPtccy1Z4vfiFGL9e7dW/pvKysrODk5WdxF0Wq1AGDxY9uNGzciICAAnTt3hkqlQlJSknQ3rdacOXPQo0cPbNiwAcnJyXBycmq0Dr1eD7VabfG+vr6+eOmllyzWteRHv4+fo1arha2tLTw9PVvUbmRkJFJTU3Hp0iUUFhZi8uTJDe7btWtX2NnZSXPk9+zZA2trawDA0qVLce3aNWzatAm9evXCpk2b0LNnT/z444+Nvv/AgQPrLJeUlAAASkpK4O7uDnd3d2m7r68vHBwcpH2Aun3t6uoqnX9ZWRmqq6sRGBgobddoNPD29m60rpKSEotj6qu1Pk96/Z05cwa5ublQqVTSq2fPnlLt9bX773OcMGECqqqq4Onpiffeew8ZGRmoqalp8Lyetk+JSF7MNeYac425JicOxKjF2rdvb7GsUCgs1tU+NenRo0cAgLS0NHz88ceIiopCTk4OioqKMG3aNFRXV1u0U1lZifPnz8PKygoXLlx46jpq19XWURtk4rEpEH///XeTbTfVblPGjh2LqqoqREVFISQkpNEgPnLkCM6ePYs7d+6gqKiozge6k5MTJkyYgFWrVqGkpARubm5YtWpVs+p4Gk9z/nLU0tj1d+/ePYSEhKCoqMjideHCBQQHBzfabm0b7u7uKC0tRWJiIpRKJUwmE4KDgxu8flp6Hm3Vp0T/dcw15hpzjbkmJw7ESDYFBQUICgqCyWSCv78/vLy8LO7Y1IqMjISfnx+2bduGefPmWdxlaQ2dO3cGAFRUVEjrHv+B87PSrl07TJkyBXl5eY3+NgAADAYDunXrZnFHqSHW1tbo1q1bk0+XOnr0aJ1lHx8fAICPjw/Ky8tRXl4ubT937hxu374NX1/fJmsAgG7duqF9+/YWv1m4detWk49l9vHxqfM7h3/X2hr69euH4uJi6PV6eHl5Wbzs7Oya3Y5SqURISAi+/PJL5OXlobCwsN67tq3Rp0T0fGOuMdfqw1yj5mrX1gXQf0f37t2xfft2HDx4EAaDATt27MCJEycsnoq0ceNGFBYW4uzZs3B3d8e+ffswefJkHD16VJrC8LSUSiUGDBiAFStWwGAwoLKyEgsXLmyVtpuyePFixMbGNjktpSHZ2dlIS0vDxIkT0aNHDwghkJWVhe+//x4pKSmNHltQUICEhASEhobi0KFD2L17N/bt2wcAGDlyJPz8/DB58mSsW7cONTU1MJlMGDJkCPr379+s2lQqFaKioqTzc3Z2xoIFCyym0tQnOjoaU6dORf/+/TFo0CDs3LkTxcXFFlNlWsPMmTOxefNmTJo0SXp61MWLF5GWloYtW7bAysqqyTZSU1NhNpsRGBgIW1tbfPPNN1AqlfDw8Kizb2v0KRE935hrzLX6MNeoufiNGMlm+vTpeOutt2A0GhEYGIibN2/CZDJJ23/++WfExsYiMTFRmn+cmJiIGzduIC4urlVrSU5ORk1NDQICAhATE4MlS5a0avsNsba2RqdOnSz+scsn4evrC1tbW8yZMwd9+/bFgAEDkJ6eji1btiA8PLzRY+fMmYOTJ0/C398fS5YswZo1azB69GgA/0wbyMzMhKOjI4KDgzFy5Eh4enriu+++e6L6Vq5ciVdffRUhISEYOXIkBg8ejICAgEaPMRqNiIuLw9y5cxEQEIBff/0VM2bMeKL3bQ43NzcUFBTAbDZj1KhR8PPzQ0xMDBwcHJoM1VoODg7YvHkzBg0ahN69e+Pw4cPIysqq9y8grdWnRPT8Yq4x1+rDXKPmUgjxhM8KJSIiIiIioqfCb8SIiIiIiIhkxoEYERERERGRzDgQIyIiIiIikhkHYkRERERERDLjQIyIiIiIiEhmHIgRERERERHJjAMxIiIiIiIimXEgRkREREREJDMOxIiIiIiIiGTGgRgREREREZHMOBAjIiIiIiKSGQdiREREREREMvsfbYIZEqIPtacAAAAASUVORK5CYII=", "text/plain": [ "
" ] diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index cd8598f51..33b22af3a 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -68,51 +68,61 @@ def init_terms(self, params) -> None: for p, q in itertools.combinations(range(norb), 2): self.add_coupling( - one_body_tensor[q, p], p, "Cdu", q, "Cu", dx0, plus_hc=True + one_body_tensor[p, q], p, "Cdu", q, "Cu", dx0, plus_hc=True ) self.add_coupling( - one_body_tensor[q, p], p, "Cdd", q, "Cd", dx0, plus_hc=True + one_body_tensor[p, q], p, "Cdd", q, "Cd", dx0, plus_hc=True ) - for p, q, r, s in itertools.product(range(norb), repeat=4): - h2 = two_body_tensor[q, p, s, r] - if not p == q == r == s: - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cu", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdu", dx0, r), - ("Cu", dx0, s), - ("Cd", dx0, q), - ], - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, p), - ("Cdd", dx0, r), - ("Cd", dx0, s), - ("Cd", dx0, q), - ], - ) + for p, s in itertools.combinations_with_replacement(range(norb), 2): + for q, r in itertools.combinations_with_replacement(range(norb), 2): + if not p == q == r == s: + indices = [(p, q, r, s)] + if p < s: + indices.append((s, q, r, p)) + if q < r: + indices.append((p, r, q, s)) + if p < s and q < r: + indices.append((s, r, q, p)) + + for i, j, k, l in indices: + h2 = two_body_tensor[i, j, k, l] + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, j), + ("Cdu", dx0, l), + ("Cu", dx0, k), + ("Cu", dx0, i), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, j), + ("Cdd", dx0, l), + ("Cd", dx0, k), + ("Cu", dx0, i), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, j), + ("Cdu", dx0, l), + ("Cu", dx0, k), + ("Cd", dx0, i), + ], + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, j), + ("Cdd", dx0, l), + ("Cd", dx0, k), + ("Cd", dx0, i), + ], + ) @staticmethod def from_molecular_hamiltonian( diff --git a/python/ffsim/testing/__init__.py b/python/ffsim/testing/__init__.py index 61d38b667..e59630ad0 100644 --- a/python/ffsim/testing/__init__.py +++ b/python/ffsim/testing/__init__.py @@ -16,7 +16,6 @@ generate_norb_nelec_spin, generate_norb_nocc, generate_norb_spin, - interaction_pairs_spin_balanced, random_nelec, random_occupied_orbitals, ) @@ -27,7 +26,6 @@ "generate_norb_nelec_spin", "generate_norb_nocc", "generate_norb_spin", - "interaction_pairs_spin_balanced", "random_nelec", "random_occupied_orbitals", ] diff --git a/python/ffsim/testing/testing.py b/python/ffsim/testing/testing.py index 0ef3629e5..4be6f0af4 100644 --- a/python/ffsim/testing/testing.py +++ b/python/ffsim/testing/testing.py @@ -153,21 +153,3 @@ def assert_allclose_up_to_global_phase( err_msg=err_msg, verbose=verbose, ) - - -def interaction_pairs_spin_balanced( - connectivity: str, norb: int -) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: - """Returns alpha-alpha and alpha-beta diagonal Coulomb interaction pairs.""" - if connectivity == "square": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb)] - elif connectivity == "hex": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb) if p % 2 == 0] - elif connectivity == "heavy-hex": - pairs_aa = [(p, p + 1) for p in range(norb - 1)] - pairs_ab = [(p, p) for p in range(norb) if p % 4 == 0] - else: - raise ValueError(f"Invalid connectivity: {connectivity}") - return pairs_aa, pairs_ab diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py index b09f83de1..b0a68057a 100644 --- a/tests/python/tenpy/gates/ucj_test.py +++ b/tests/python/tenpy/gates/ucj_test.py @@ -18,7 +18,7 @@ from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps -from ffsim.testing import interaction_pairs_spin_balanced +from variational.util import interaction_pairs_spin_balanced @pytest.mark.parametrize( From 62f9ec577683ba126144ae2945189b5dcea43b22 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sat, 23 Nov 2024 11:48:20 +0100 Subject: [PATCH 67/88] fix minor errors --- .../tenpy/hamiltonians/molecular_hamiltonian.py | 16 ++++++++-------- tests/python/tenpy/gates/ucj_test.py | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 33b22af3a..accca1786 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -68,10 +68,10 @@ def init_terms(self, params) -> None: for p, q in itertools.combinations(range(norb), 2): self.add_coupling( - one_body_tensor[p, q], p, "Cdu", q, "Cu", dx0, plus_hc=True + one_body_tensor[p, q], q, "Cdu", p, "Cu", dx0, plus_hc=True ) self.add_coupling( - one_body_tensor[p, q], p, "Cdd", q, "Cd", dx0, plus_hc=True + one_body_tensor[p, q], q, "Cdd", p, "Cd", dx0, plus_hc=True ) for p, s in itertools.combinations_with_replacement(range(norb), 2): @@ -85,13 +85,13 @@ def init_terms(self, params) -> None: if p < s and q < r: indices.append((s, r, q, p)) - for i, j, k, l in indices: - h2 = two_body_tensor[i, j, k, l] + for i, j, k, ell in indices: + h2 = two_body_tensor[i, j, k, ell] self.add_multi_coupling( 0.5 * h2, [ ("Cdu", dx0, j), - ("Cdu", dx0, l), + ("Cdu", dx0, ell), ("Cu", dx0, k), ("Cu", dx0, i), ], @@ -100,7 +100,7 @@ def init_terms(self, params) -> None: 0.5 * h2, [ ("Cdu", dx0, j), - ("Cdd", dx0, l), + ("Cdd", dx0, ell), ("Cd", dx0, k), ("Cu", dx0, i), ], @@ -109,7 +109,7 @@ def init_terms(self, params) -> None: 0.5 * h2, [ ("Cdd", dx0, j), - ("Cdu", dx0, l), + ("Cdu", dx0, ell), ("Cu", dx0, k), ("Cd", dx0, i), ], @@ -118,7 +118,7 @@ def init_terms(self, params) -> None: 0.5 * h2, [ ("Cdd", dx0, j), - ("Cdd", dx0, l), + ("Cdd", dx0, ell), ("Cd", dx0, k), ("Cd", dx0, i), ], diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py index b0a68057a..ffdd559bc 100644 --- a/tests/python/tenpy/gates/ucj_test.py +++ b/tests/python/tenpy/gates/ucj_test.py @@ -18,7 +18,7 @@ from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel from ffsim.tenpy.util import bitstring_to_mps -from variational.util import interaction_pairs_spin_balanced +from ffsim.variational.util import interaction_pairs_spin_balanced @pytest.mark.parametrize( From 7ed0f2c646246d74acd23ce3cc00d706577ec734 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Sat, 23 Nov 2024 11:58:22 +0100 Subject: [PATCH 68/88] further simplify two_body_tensor loop in molecular Hamiltonian --- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index accca1786..628d6cb21 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -82,10 +82,9 @@ def init_terms(self, params) -> None: indices.append((s, q, r, p)) if q < r: indices.append((p, r, q, s)) - if p < s and q < r: - indices.append((s, r, q, p)) - for i, j, k, ell in indices: + for idx, (i, j, k, ell) in enumerate(indices): + flag_hc = True if not idx and i < ell and j < k else False h2 = two_body_tensor[i, j, k, ell] self.add_multi_coupling( 0.5 * h2, @@ -95,6 +94,7 @@ def init_terms(self, params) -> None: ("Cu", dx0, k), ("Cu", dx0, i), ], + plus_hc=flag_hc, ) self.add_multi_coupling( 0.5 * h2, @@ -104,6 +104,7 @@ def init_terms(self, params) -> None: ("Cd", dx0, k), ("Cu", dx0, i), ], + plus_hc=flag_hc, ) self.add_multi_coupling( 0.5 * h2, @@ -113,6 +114,7 @@ def init_terms(self, params) -> None: ("Cu", dx0, k), ("Cd", dx0, i), ], + plus_hc=flag_hc, ) self.add_multi_coupling( 0.5 * h2, @@ -122,6 +124,7 @@ def init_terms(self, params) -> None: ("Cd", dx0, k), ("Cd", dx0, i), ], + plus_hc=flag_hc, ) @staticmethod From 6efd6d70dd65f62856fd588195c7b82fd56a68eb Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 28 Nov 2024 11:41:07 +0100 Subject: [PATCH 69/88] refactor molecular hamiltonian --- .../hamiltonians/molecular_hamiltonian.py | 73 +++++++++++++++---- 1 file changed, 60 insertions(+), 13 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 628d6cb21..509080040 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -56,35 +56,82 @@ def init_terms(self, params) -> None: norb = one_body_tensor.shape[0] for p in range(norb): + # one-body tensor h1 = one_body_tensor[p, p] self.add_onsite(h1, p, "Ntot") + # two-body tensor h2 = two_body_tensor[p, p, p, p] self.add_onsite(h2, p, "Ntot") self.add_onsite(-0.5 * h2, p, "Nu Nu") self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") self.add_onsite(-0.5 * h2, p, "Nd Nd") + # constant self.add_onsite(constant / norb, p, "Id") for p, q in itertools.combinations(range(norb), 2): - self.add_coupling( - one_body_tensor[p, q], q, "Cdu", p, "Cu", dx0, plus_hc=True - ) - self.add_coupling( - one_body_tensor[p, q], q, "Cdd", p, "Cd", dx0, plus_hc=True - ) + # one-body tensor + h1 = one_body_tensor[p, q] + self.add_coupling(h1, q, "Cdu", p, "Cu", dx0, plus_hc=True) + self.add_coupling(h1, q, "Cdd", p, "Cd", dx0, plus_hc=True) + # two-body tensor + indices = [(p, p, q, q), (p, q, p, q), (p, q, q, p)] + for i, j, k, ell in indices: + h2 = two_body_tensor[i, j, k, ell] + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, j), + ("Cdu", dx0, ell), + ("Cu", dx0, k), + ("Cu", dx0, i), + ], + plus_hc=True, + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdu", dx0, j), + ("Cdd", dx0, ell), + ("Cd", dx0, k), + ("Cu", dx0, i), + ], + plus_hc=True, + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, j), + ("Cdu", dx0, ell), + ("Cu", dx0, k), + ("Cd", dx0, i), + ], + plus_hc=True, + ) + self.add_multi_coupling( + 0.5 * h2, + [ + ("Cdd", dx0, j), + ("Cdd", dx0, ell), + ("Cd", dx0, k), + ("Cd", dx0, i), + ], + plus_hc=True, + ) for p, s in itertools.combinations_with_replacement(range(norb), 2): for q, r in itertools.combinations_with_replacement(range(norb), 2): - if not p == q == r == s: + values, counts = np.unique([p, q, r, s], return_counts=True) + if not (len(values) in [1, 2] and len(set(counts)) == 1): + # two-body tensor indices = [(p, q, r, s)] - if p < s: - indices.append((s, q, r, p)) - if q < r: - indices.append((p, r, q, s)) - + if p != s: + indices.append((s, q, r, p)) # swap p and s + if q != r: + indices.append((p, r, q, s)) # swap q and r for idx, (i, j, k, ell) in enumerate(indices): - flag_hc = True if not idx and i < ell and j < k else False + # reverse p, q, r, s by adding hermitian conjugate + flag_hc = True if not idx and i != ell and j != k else False h2 = two_body_tensor[i, j, k, ell] self.add_multi_coupling( 0.5 * h2, From e2ab247e601ef447729d82aea8c0c50fcb3b1eba Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 29 Nov 2024 16:09:03 +0100 Subject: [PATCH 70/88] expand molecular Hamiltonian test --- docs/how-to-guides/lucj_mps.ipynb | 26 +++---- python/ffsim/tenpy/gates/abstract_gates.py | 2 +- python/ffsim/tenpy/gates/diag_coulomb.py | 2 +- python/ffsim/tenpy/gates/orbital_rotation.py | 2 +- python/ffsim/tenpy/gates/ucj.py | 2 +- .../molecular_hamiltonian_test.py | 69 +++++++++++++------ 6 files changed, 64 insertions(+), 39 deletions(-) diff --git a/docs/how-to-guides/lucj_mps.ipynb b/docs/how-to-guides/lucj_mps.ipynb index e0b322c26..4e4670957 100644 --- a/docs/how-to-guides/lucj_mps.ipynb +++ b/docs/how-to-guides/lucj_mps.ipynb @@ -41,10 +41,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "converged SCF energy = -77.8266321248744\n", - "Parsing /tmp/tmpgbjtc5ah\n", - "converged SCF energy = -77.8266321248744\n", - "CASCI E = -77.8742165643863 E(CI) = -4.02122442107773 S^2 = 0.0000000\n", + "converged SCF energy = -77.8266321248745\n", + "Parsing /tmp/tmpe0z457lb\n", + "converged SCF energy = -77.8266321248745\n", + "CASCI E = -77.8742165643863 E(CI) = -4.02122442107772 S^2 = 0.0000000\n", "norb = 4\n", "nelec = (2, 2)\n" ] @@ -126,17 +126,17 @@ }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "E(CCSD) = -77.87421536374029 E_corr = -0.04758323886585428\n" + " does not have attributes converged\n" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " does not have attributes converged\n" + "E(CCSD) = -77.87421536374032 E_corr = -0.04758323886585007\n" ] } ], @@ -193,7 +193,7 @@ "text": [ "original Hamiltonian type = \n", "converted Hamiltonian type = \n", - "maximum MPO bond dimension = 58\n" + "maximum MPO bond dimension = 54\n" ] } ], @@ -307,9 +307,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "LUCJ (MPS) energy = -77.77309168986469\n", - "LUCJ energy = -77.84651018653344\n", - "FCI energy = -77.87421656438626\n" + "LUCJ (MPS) energy = -77.77309168986461\n", + "LUCJ energy = -77.84651018653356\n", + "FCI energy = -77.87421656438629\n" ] } ], @@ -351,7 +351,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/python/ffsim/tenpy/gates/abstract_gates.py b/python/ffsim/tenpy/gates/abstract_gates.py index e8afdbb1c..10b505819 100644 --- a/python/ffsim/tenpy/gates/abstract_gates.py +++ b/python/ffsim/tenpy/gates/abstract_gates.py @@ -45,7 +45,7 @@ def apply_two_site( U2: np.ndarray, sites: tuple[int, int], *, - norm_tol: float = 1e-5, + norm_tol: float = 1e-8, ) -> None: r"""Apply a two-site gate to an MPS. diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py index 5c7201356..433b336c7 100644 --- a/python/ffsim/tenpy/gates/diag_coulomb.py +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -24,7 +24,7 @@ def apply_diag_coulomb_evolution( mat: np.ndarray, time: float, *, - norm_tol: float = 1e-5, + norm_tol: float = 1e-8, ) -> None: r"""Apply a diagonal Coulomb evolution gate to an MPS. diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py index eece2c125..abd1fe9b5 100644 --- a/python/ffsim/tenpy/gates/orbital_rotation.py +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -25,7 +25,7 @@ def apply_orbital_rotation( eng: TEBDEngine, mat: np.ndarray, *, - norm_tol: float = 1e-5, + norm_tol: float = 1e-8, ) -> None: r"""Apply an orbital rotation gate to an MPS. diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index 070e91df0..6d7ebbd98 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -24,7 +24,7 @@ def apply_ucj_op_spin_balanced( eng: TEBDEngine, ucj_op: UCJOpSpinBalanced, *, - norm_tol: float = 1e-5, + norm_tol: float = 1e-8, ) -> None: r"""Apply a spin-balanced unitary cluster Jastrow gate to an MPS. diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 173d4bc5d..805e991f9 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -10,6 +10,8 @@ """Tests for the TeNPy molecular Hamiltonian.""" +import itertools + import numpy as np import pytest @@ -21,10 +23,10 @@ @pytest.mark.parametrize( "norb, nelec", [ - (4, (2, 2)), - (4, (1, 2)), - (4, (0, 2)), - (4, (0, 0)), + (2, (2, 2)), + (2, (1, 2)), + (2, (0, 2)), + (2, (0, 0)), ], ) def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): @@ -41,24 +43,47 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO - # generate a random product state dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - product_state = ffsim.linalg.one_hot(dim, idx) + for idx1, idx2 in itertools.product(range(dim), repeat=2): + # generate product states + product_state_1 = ffsim.linalg.one_hot(dim, idx1) + product_state_2 = ffsim.linalg.one_hot(dim, idx2) - # convert product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - product_state_mps = bitstring_to_mps( - (int(strings_a[0], 2), int(strings_b[0], 2)), norb - ) + # convert product states to MPS + strings_a_1, strings_b_1 = ffsim.addresses_to_strings( + [idx1], + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + product_state_mps_1 = bitstring_to_mps( + (int(strings_a_1[0], 2), int(strings_b_1[0], 2)), norb + ) + strings_a_2, strings_b_2 = ffsim.addresses_to_strings( + [idx2], + norb=norb, + nelec=nelec, + bitstring_type=ffsim.BitstringType.STRING, + concatenate=False, + ) + product_state_mps_2 = bitstring_to_mps( + (int(strings_a_2[0], 2), int(strings_b_2[0], 2)), norb + ) - # test expectation is preserved - original_expectation = np.vdot(product_state, hamiltonian @ product_state) - mpo_expectation = mol_hamiltonian_mpo.expectation_value_finite(product_state_mps) - np.testing.assert_allclose(original_expectation, mpo_expectation) + # test expectation is preserved + original_expectation = np.vdot(product_state_1, hamiltonian @ product_state_2) + mol_hamiltonian_mpo.apply_naively(product_state_mps_2) + mpo_expectation = product_state_mps_1.overlap(product_state_mps_2) + np.testing.assert_allclose( + abs(original_expectation.real), + abs(mpo_expectation.real), + rtol=1e-05, + atol=1e-08, + ) + np.testing.assert_allclose( + abs(original_expectation.imag), + abs(mpo_expectation.imag), + rtol=1e-05, + atol=1e-08, + ) From 8b4e6c17fbb2ca273fcc4453167fd97cb58b2ebf Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Sat, 7 Dec 2024 21:31:59 -0500 Subject: [PATCH 71/88] revert mol hamiltonian test comparison --- .../hamiltonians/molecular_hamiltonian_test.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 805e991f9..a0dcebc67 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -75,15 +75,4 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): original_expectation = np.vdot(product_state_1, hamiltonian @ product_state_2) mol_hamiltonian_mpo.apply_naively(product_state_mps_2) mpo_expectation = product_state_mps_1.overlap(product_state_mps_2) - np.testing.assert_allclose( - abs(original_expectation.real), - abs(mpo_expectation.real), - rtol=1e-05, - atol=1e-08, - ) - np.testing.assert_allclose( - abs(original_expectation.imag), - abs(mpo_expectation.imag), - rtol=1e-05, - atol=1e-08, - ) + np.testing.assert_allclose(original_expectation, mpo_expectation) From 864b0b07828b8708f9432b2b362b542611c8d10c Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 20 Dec 2024 15:48:36 -0500 Subject: [PATCH 72/88] update test --- .../tenpy/hamiltonians/molecular_hamiltonian_test.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index a0dcebc67..8b28e4aaf 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -24,6 +24,7 @@ "norb, nelec", [ (2, (2, 2)), + (2, (2, 1)), (2, (1, 2)), (2, (0, 2)), (2, (0, 0)), @@ -54,22 +55,16 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): [idx1], norb=norb, nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - product_state_mps_1 = bitstring_to_mps( - (int(strings_a_1[0], 2), int(strings_b_1[0], 2)), norb - ) + product_state_mps_1 = bitstring_to_mps((strings_a_1[0], strings_b_1[0]), norb) strings_a_2, strings_b_2 = ffsim.addresses_to_strings( [idx2], norb=norb, nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, concatenate=False, ) - product_state_mps_2 = bitstring_to_mps( - (int(strings_a_2[0], 2), int(strings_b_2[0], 2)), norb - ) + product_state_mps_2 = bitstring_to_mps((strings_a_2[0], strings_b_2[0]), norb) # test expectation is preserved original_expectation = np.vdot(product_state_1, hamiltonian @ product_state_2) From fb7f9a859f50de6279e12cf8a40b95b3277036ee Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 20 Dec 2024 15:56:16 -0500 Subject: [PATCH 73/88] simplify bitstring_to_mps --- python/ffsim/tenpy/util.py | 33 ++++++++++++--------------------- 1 file changed, 12 insertions(+), 21 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index e237cc68a..4318d90bd 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -29,29 +29,20 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: # unpack bitstrings int_a, int_b = bitstring - string_a = f"{int_a:0{norb}b}" - string_b = f"{int_b:0{norb}b}" - - # merge bitstrings - up_sector = string_a.replace("1", "u") - down_sector = string_b.replace("1", "d") - product_state = [a + b for a, b in zip(up_sector, down_sector)] + string_a = format(int_a, f"0{norb}b") + string_b = format(int_b, f"0{norb}b") # relabel using TeNPy SpinHalfFermionSite convention - for i, site in enumerate(product_state): - if site == "00": - product_state[i] = "empty" - elif site == "u0": - product_state[i] = "up" - elif site == "0d": - product_state[i] = "down" - elif site == "ud": - product_state[i] = "full" - else: - raise ValueError("undefined site") - - # note that the bit positions increase from right to left - product_state = product_state[::-1] + product_state = [] + for site in zip(reversed(string_a), reversed(string_b)): + if site == ("0", "0"): + product_state.append("empty") + elif site == ("1", "0"): + product_state.append("up") + elif site == ("0", "1"): + product_state.append("down") + else: # site == ("1", "1"): + product_state.append("full") # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") From f4f63c892ed61b5235ab4c41fa3aa97d7eb79da4 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 20 Dec 2024 16:17:09 -0500 Subject: [PATCH 74/88] simplify molecular hamiltonian MPO (sign issue still present) --- .../hamiltonians/molecular_hamiltonian.py | 154 +++++------------- 1 file changed, 38 insertions(+), 116 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 509080040..6b6bc353c 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -49,130 +49,52 @@ def init_lattice(self, params) -> Lattice: def init_terms(self, params) -> None: """Initialize terms.""" - dx0 = np.array([0, 0]) one_body_tensor = params.get("one_body_tensor", None, expect_type="array") two_body_tensor = params.get("two_body_tensor", None, expect_type="array") constant = params.get("constant", 0, expect_type="real") norb = one_body_tensor.shape[0] + # constant for p in range(norb): - # one-body tensor - h1 = one_body_tensor[p, p] - self.add_onsite(h1, p, "Ntot") - # two-body tensor - h2 = two_body_tensor[p, p, p, p] - self.add_onsite(h2, p, "Ntot") - self.add_onsite(-0.5 * h2, p, "Nu Nu") - self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") - self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") - self.add_onsite(-0.5 * h2, p, "Nd Nd") - # constant self.add_onsite(constant / norb, p, "Id") - for p, q in itertools.combinations(range(norb), 2): - # one-body tensor - h1 = one_body_tensor[p, q] - self.add_coupling(h1, q, "Cdu", p, "Cu", dx0, plus_hc=True) - self.add_coupling(h1, q, "Cdd", p, "Cd", dx0, plus_hc=True) - # two-body tensor - indices = [(p, p, q, q), (p, q, p, q), (p, q, q, p)] - for i, j, k, ell in indices: - h2 = two_body_tensor[i, j, k, ell] - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, j), - ("Cdu", dx0, ell), - ("Cu", dx0, k), - ("Cu", dx0, i), - ], - plus_hc=True, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, j), - ("Cdd", dx0, ell), - ("Cd", dx0, k), - ("Cu", dx0, i), - ], - plus_hc=True, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, j), - ("Cdu", dx0, ell), - ("Cu", dx0, k), - ("Cd", dx0, i), - ], - plus_hc=True, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, j), - ("Cdd", dx0, ell), - ("Cd", dx0, k), - ("Cd", dx0, i), - ], - plus_hc=True, - ) - - for p, s in itertools.combinations_with_replacement(range(norb), 2): - for q, r in itertools.combinations_with_replacement(range(norb), 2): - values, counts = np.unique([p, q, r, s], return_counts=True) - if not (len(values) in [1, 2] and len(set(counts)) == 1): - # two-body tensor - indices = [(p, q, r, s)] - if p != s: - indices.append((s, q, r, p)) # swap p and s - if q != r: - indices.append((p, r, q, s)) # swap q and r - for idx, (i, j, k, ell) in enumerate(indices): - # reverse p, q, r, s by adding hermitian conjugate - flag_hc = True if not idx and i != ell and j != k else False - h2 = two_body_tensor[i, j, k, ell] - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, j), - ("Cdu", dx0, ell), - ("Cu", dx0, k), - ("Cu", dx0, i), - ], - plus_hc=flag_hc, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdu", dx0, j), - ("Cdd", dx0, ell), - ("Cd", dx0, k), - ("Cu", dx0, i), - ], - plus_hc=flag_hc, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, j), - ("Cdu", dx0, ell), - ("Cu", dx0, k), - ("Cd", dx0, i), - ], - plus_hc=flag_hc, - ) - self.add_multi_coupling( - 0.5 * h2, - [ - ("Cdd", dx0, j), - ("Cdd", dx0, ell), - ("Cd", dx0, k), - ("Cd", dx0, i), - ], - plus_hc=flag_hc, - ) + # one-body terms + for p, q in itertools.product(range(norb), repeat=2): + self._add_one_body(one_body_tensor[p, q], p, q) + + # two-body terms + for p, q, r, s in itertools.product(range(norb), repeat=4): + self._add_two_body(0.5 * two_body_tensor[p, q, r, s], p, q, r, s) + + def _add_one_body(self, coeff: complex, p: int, q: int) -> None: + if p == q: + self.add_onsite(coeff, p, "Ntot") + else: + dx0 = np.zeros(2) + self.add_coupling(coeff, p, "Cdu", q, "Cu", dx0) + self.add_coupling(coeff, p, "Cdd", q, "Cd", dx0) + + def _add_two_body(self, coeff: complex, p: int, q: int, r: int, s: int) -> None: + if p == q == r == s: + self.add_onsite(2 * coeff, p, "Nu Nd") + else: + dx0 = np.zeros(2) + self.add_multi_coupling( + coeff, + [("Cdu", dx0, p), ("Cdu", dx0, r), ("Cu", dx0, s), ("Cu", dx0, q)], + ) + self.add_multi_coupling( + coeff, + [("Cdu", dx0, p), ("Cdd", dx0, r), ("Cd", dx0, s), ("Cu", dx0, q)], + ) + self.add_multi_coupling( + coeff, + [("Cdd", dx0, p), ("Cdu", dx0, r), ("Cu", dx0, s), ("Cd", dx0, q)], + ) + self.add_multi_coupling( + coeff, + [("Cdd", dx0, p), ("Cdd", dx0, r), ("Cd", dx0, s), ("Cd", dx0, q)], + ) @staticmethod def from_molecular_hamiltonian( From 74e45795ef58de33338cfab1f8588e25c4e621d4 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 20 Dec 2024 16:30:21 -0500 Subject: [PATCH 75/88] simplify test --- .../molecular_hamiltonian_test.py | 34 ++++++++----------- 1 file changed, 14 insertions(+), 20 deletions(-) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 8b28e4aaf..8775ebe95 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -45,29 +45,23 @@ def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO dim = ffsim.dim(norb, nelec) - for idx1, idx2 in itertools.product(range(dim), repeat=2): + strings = ffsim.addresses_to_strings( + range(dim), norb=norb, nelec=nelec, concatenate=False + ) + + for (i, string_i), (j, string_j) in itertools.product( + enumerate(zip(*strings)), repeat=2 + ): # generate product states - product_state_1 = ffsim.linalg.one_hot(dim, idx1) - product_state_2 = ffsim.linalg.one_hot(dim, idx2) + product_state_i = ffsim.linalg.one_hot(dim, i) + product_state_j = ffsim.linalg.one_hot(dim, j) # convert product states to MPS - strings_a_1, strings_b_1 = ffsim.addresses_to_strings( - [idx1], - norb=norb, - nelec=nelec, - concatenate=False, - ) - product_state_mps_1 = bitstring_to_mps((strings_a_1[0], strings_b_1[0]), norb) - strings_a_2, strings_b_2 = ffsim.addresses_to_strings( - [idx2], - norb=norb, - nelec=nelec, - concatenate=False, - ) - product_state_mps_2 = bitstring_to_mps((strings_a_2[0], strings_b_2[0]), norb) + product_state_mps_i = bitstring_to_mps(string_i, norb) + product_state_mps_j = bitstring_to_mps(string_j, norb) # test expectation is preserved - original_expectation = np.vdot(product_state_1, hamiltonian @ product_state_2) - mol_hamiltonian_mpo.apply_naively(product_state_mps_2) - mpo_expectation = product_state_mps_1.overlap(product_state_mps_2) + original_expectation = np.vdot(product_state_i, hamiltonian @ product_state_j) + mol_hamiltonian_mpo.apply_naively(product_state_mps_j) + mpo_expectation = product_state_mps_i.overlap(product_state_mps_j) np.testing.assert_allclose(original_expectation, mpo_expectation) From fc11ae36ae25c88c6747cf00981d8b4c6c306b58 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Fri, 20 Dec 2024 16:45:02 -0500 Subject: [PATCH 76/88] add test case --- tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 8775ebe95..ea3dbd115 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -26,6 +26,7 @@ (2, (2, 2)), (2, (2, 1)), (2, (1, 2)), + (2, (1, 1)), (2, (0, 2)), (2, (0, 0)), ], From 49a0b568fea54f9bcde9ed98548267127968312b Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 6 Jan 2025 16:25:31 +0100 Subject: [PATCH 77/88] catch trivial one_body_tensor parameter --- .../tenpy/hamiltonians/molecular_hamiltonian.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 6b6bc353c..9021329a1 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -34,6 +34,9 @@ def init_sites(self, params) -> SpinHalfFermionSite: def init_lattice(self, params) -> Lattice: """Initialize lattice.""" + assert params.has_nonzero( + "one_body_tensor" + ), "required parameter one_body_tensor is zero or None" one_body_tensor = params.get("one_body_tensor", None, expect_type="array") norb = one_body_tensor.shape[0] site = self.init_sites(params) @@ -49,10 +52,15 @@ def init_lattice(self, params) -> Lattice: def init_terms(self, params) -> None: """Initialize terms.""" + assert params.has_nonzero( + "one_body_tensor" + ), "required parameter one_body_tensor is zero or None" one_body_tensor = params.get("one_body_tensor", None, expect_type="array") - two_body_tensor = params.get("two_body_tensor", None, expect_type="array") - constant = params.get("constant", 0, expect_type="real") norb = one_body_tensor.shape[0] + two_body_tensor = params.get( + "two_body_tensor", np.zeros((norb, norb, norb, norb)), expect_type="array" + ) + constant = params.get("constant", 0, expect_type="real") # constant for p in range(norb): From 8e67e2751fdb996c275e0373648ffd67d34b6f8d Mon Sep 17 00:00:00 2001 From: bartandrews Date: Mon, 6 Jan 2025 16:38:06 +0100 Subject: [PATCH 78/88] add correct TeNPy version in dependencies (post license change to Apache-2.0) --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index d18397b5d..0667b9d91 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,7 +26,7 @@ dependencies = [ "numpy", "opt_einsum", "orjson", - "physics-tenpy", + "physics-tenpy >= 1.0.4", "pyscf >= 2.7", "qiskit >= 1.1", "scipy", From 4a97669e5f0f1094b8fca503b25892aec26fc5a7 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 7 Jan 2025 11:39:33 +0100 Subject: [PATCH 79/88] make one_body_tensor a required parameter of MolecularHamiltonianMPOModel --- .../hamiltonians/molecular_hamiltonian.py | 42 ++++++++++--------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 9021329a1..d068c6bc7 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -28,23 +28,30 @@ class MolecularHamiltonianMPOModel(CouplingMPOModel): """Molecular Hamiltonian.""" + def __init__(self, params): + if "one_body_tensor" in params and isinstance( + params["one_body_tensor"], np.ndarray + ): + self.one_body_tensor = params["one_body_tensor"] + else: + raise ValueError( + "required parameter one_body_tensor is undefined or not an array" + ) + self.norb = self.one_body_tensor.shape[0] + CouplingMPOModel.__init__(self, params) + def init_sites(self, params) -> SpinHalfFermionSite: """Initialize sites.""" return SpinHalfFermionSite() def init_lattice(self, params) -> Lattice: """Initialize lattice.""" - assert params.has_nonzero( - "one_body_tensor" - ), "required parameter one_body_tensor is zero or None" - one_body_tensor = params.get("one_body_tensor", None, expect_type="array") - norb = one_body_tensor.shape[0] site = self.init_sites(params) - basis = np.array(([norb, 0], [0, 1])) - pos = np.array([[i, 0] for i in range(norb)]) + basis = np.array(([self.norb, 0], [0, 1])) + pos = np.array([[i, 0] for i in range(self.norb)]) lat = Lattice( [1, 1], - [site] * norb, + [site] * self.norb, basis=basis, positions=pos, ) @@ -52,26 +59,23 @@ def init_lattice(self, params) -> Lattice: def init_terms(self, params) -> None: """Initialize terms.""" - assert params.has_nonzero( - "one_body_tensor" - ), "required parameter one_body_tensor is zero or None" - one_body_tensor = params.get("one_body_tensor", None, expect_type="array") - norb = one_body_tensor.shape[0] two_body_tensor = params.get( - "two_body_tensor", np.zeros((norb, norb, norb, norb)), expect_type="array" + "two_body_tensor", + np.zeros((self.norb, self.norb, self.norb, self.norb)), + expect_type="array", ) constant = params.get("constant", 0, expect_type="real") # constant - for p in range(norb): - self.add_onsite(constant / norb, p, "Id") + for p in range(self.norb): + self.add_onsite(constant / self.norb, p, "Id") # one-body terms - for p, q in itertools.product(range(norb), repeat=2): - self._add_one_body(one_body_tensor[p, q], p, q) + for p, q in itertools.product(range(self.norb), repeat=2): + self._add_one_body(self.one_body_tensor[p, q], p, q) # two-body terms - for p, q, r, s in itertools.product(range(norb), repeat=4): + for p, q, r, s in itertools.product(range(self.norb), repeat=4): self._add_two_body(0.5 * two_body_tensor[p, q, r, s], p, q, r, s) def _add_one_body(self, coeff: complex, p: int, q: int) -> None: From a451c695c5ad9d4d9848d60fcc2ccae150bce052 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 7 Jan 2025 13:37:32 +0100 Subject: [PATCH 80/88] touch one_body_tensor --- python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index d068c6bc7..bff91b1c0 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -59,6 +59,7 @@ def init_lattice(self, params) -> Lattice: def init_terms(self, params) -> None: """Initialize terms.""" + params.touch("one_body_tensor") # suppress unused key warning two_body_tensor = params.get( "two_body_tensor", np.zeros((self.norb, self.norb, self.norb, self.norb)), From f53f6aaa19e3da3b0e048c90652fba164125cf53 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Tue, 7 Jan 2025 17:25:23 +0100 Subject: [PATCH 81/88] map from ffsim to TeNPy ordering in bitstring_to_mps --- python/ffsim/tenpy/util.py | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 4318d90bd..cadf4ac00 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -12,6 +12,7 @@ from __future__ import annotations +import tenpy.linalg.np_conserved as npc from tenpy.networks.mps import MPS from tenpy.networks.site import SpinHalfFermionSite @@ -33,8 +34,8 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: string_b = format(int_b, f"0{norb}b") # relabel using TeNPy SpinHalfFermionSite convention - product_state = [] - for site in zip(reversed(string_a), reversed(string_b)): + product_state, swap_factors = [], [] + for i, site in enumerate(zip(reversed(string_a), reversed(string_b))): if site == ("0", "0"): product_state.append("empty") elif site == ("1", "0"): @@ -44,8 +45,25 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: else: # site == ("1", "1"): product_state.append("full") + if i > 0: + if product_state[-1] in ["up", "full"] and product_state[-2] in [ + "down", + "full", + ]: + swap_factors.append(-1) + else: + swap_factors.append(1) + # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") mps = MPS.from_product_state([shfs] * norb, product_state) + # map from ffsim to TeNPy ordering + minus_identity_npc = npc.Array.from_ndarray( + -shfs.get_op("Id").to_ndarray(), [shfs.leg, shfs.leg.conj()], labels=["p", "p*"] + ) + for i, swap_factor in enumerate(swap_factors): + if swap_factor == -1: + mps.apply_local_op(i, minus_identity_npc) + return mps From 83e4bbebd315478220a613afb95c9c1ad473e58f Mon Sep 17 00:00:00 2001 From: bartandrews Date: Wed, 8 Jan 2025 17:00:57 +0100 Subject: [PATCH 82/88] make gates consistent with ffsim-TeNPy ordering --- python/ffsim/tenpy/gates/basic_gates.py | 36 +++++++++---------- python/ffsim/tenpy/gates/orbital_rotation.py | 4 +-- python/ffsim/tenpy/gates/ucj.py | 2 +- tests/python/tenpy/gates/basic_gates_test.py | 4 +-- .../tenpy/gates/orbital_rotation_test.py | 2 +- 5 files changed, 24 insertions(+), 24 deletions(-) diff --git a/python/ffsim/tenpy/gates/basic_gates.py b/python/ffsim/tenpy/gates/basic_gates.py index 37c85b922..a52afaa1d 100644 --- a/python/ffsim/tenpy/gates/basic_gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -79,21 +79,21 @@ def givens_rotation( # Ggate_a = ( # np.kron(sp.linalg.expm(1j * phi * Nu), Id) # @ sp.linalg.expm( - # theta * (np.kron(Cdu @ JW, Cu @ JWu) - np.kron(Cu @ JW, Cdu @ JWu)) + # theta * (np.kron(Cdu @ JWd, Cu @ Id) - np.kron(Cu @ JWd, Cdu @ Id)) # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) # ) Ggate_a = np.diag( np.array([1, c, 1, c, c, 1, c, 1, 1, c, 1, c, c, 1, c, 1], dtype=complex) ) - Ggate_a[1, 4] = -s - Ggate_a[3, 6] = -s - Ggate_a[9, 12] = s - Ggate_a[11, 14] = s - Ggate_a[4, 1] = s.conjugate() - Ggate_a[6, 3] = s.conjugate() - Ggate_a[12, 9] = -s.conjugate() - Ggate_a[14, 11] = -s.conjugate() + Ggate_a[1, 4] = s + Ggate_a[3, 6] = s + Ggate_a[9, 12] = -s + Ggate_a[11, 14] = -s + Ggate_a[4, 1] = -s.conjugate() + Ggate_a[6, 3] = -s.conjugate() + Ggate_a[12, 9] = s.conjugate() + Ggate_a[14, 11] = s.conjugate() # beta sector / down spins if spin in [Spin.BETA, Spin.ALPHA_AND_BETA]: @@ -101,21 +101,21 @@ def givens_rotation( # Ggate_b = ( # np.kron(sp.linalg.expm(1j * phi * Nd), Id) # @ sp.linalg.expm( - # theta * (np.kron(Cdd @ JW, Cd @ JWd) - np.kron(Cd @ JW, Cdd @ JWd)) + # theta * (np.kron(Cdd @ JWu, Cd @ Id) - np.kron(Cd @ JWu, Cdd @ Id)) # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) # ) Ggate_b = np.diag( np.array([1, 1, c, c, 1, 1, c, c, c, c, 1, 1, c, c, 1, 1], dtype=complex) ) - Ggate_b[2, 8] = -s - Ggate_b[3, 9] = s - Ggate_b[6, 12] = -s - Ggate_b[7, 13] = s - Ggate_b[8, 2] = s.conjugate() - Ggate_b[9, 3] = -s.conjugate() - Ggate_b[12, 6] = s.conjugate() - Ggate_b[13, 7] = -s.conjugate() + Ggate_b[2, 8] = s + Ggate_b[3, 9] = -s + Ggate_b[6, 12] = s + Ggate_b[7, 13] = -s + Ggate_b[8, 2] = -s.conjugate() + Ggate_b[9, 3] = s.conjugate() + Ggate_b[12, 6] = -s.conjugate() + Ggate_b[13, 7] = s.conjugate() # define total gate if spin is Spin.ALPHA: diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py index abd1fe9b5..92daa63bc 100644 --- a/python/ffsim/tenpy/gates/orbital_rotation.py +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -50,7 +50,7 @@ def apply_orbital_rotation( # apply the Givens rotation gates for gate in givens_list: theta = math.acos(gate.c) - phi = cmath.phase(gate.s) - np.pi + phi = -cmath.phase(gate.s) apply_two_site( eng, givens_rotation(theta, phi=phi), @@ -61,4 +61,4 @@ def apply_orbital_rotation( # apply the number interaction gates for i, z in enumerate(diag_mat): theta = cmath.phase(z) - apply_single_site(eng, num_interaction(-theta), i) + apply_single_site(eng, num_interaction(theta), i) diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index 6d7ebbd98..ddd43c771 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -55,7 +55,7 @@ def apply_ucj_op_spin_balanced( orb_rot.conjugate().T @ current_basis, norm_tol=norm_tol, ) - apply_diag_coulomb_evolution(eng, diag_mats, 1, norm_tol=norm_tol) + apply_diag_coulomb_evolution(eng, diag_mats, -1, norm_tol=norm_tol) current_basis = orb_rot if ucj_op.final_orbital_rotation is None: apply_orbital_rotation( diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index 4fc3eab6e..917c46fa9 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -87,12 +87,12 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): # apply random orbital rotation to MPS eng = TEBDEngine(mps, None, {}) - ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p + 1, p)) + ffsim.tenpy.apply_two_site(eng, givens_rotation(theta, spin, phi=phi), (p, p + 1)) # test expectation is preserved original_expectation = np.vdot(original_vec, hamiltonian @ vec) mol_hamiltonian_mpo.apply_naively(mps) - mpo_expectation = mps.overlap(original_mps) + mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 0d60a127b..218da7ed4 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -76,5 +76,5 @@ def test_apply_orbital_rotation( # test expectation is preserved original_expectation = np.vdot(original_vec, hamiltonian @ vec) mol_hamiltonian_mpo.apply_naively(mps) - mpo_expectation = mps.overlap(original_mps) + mpo_expectation = original_mps.overlap(mps) np.testing.assert_allclose(original_expectation, mpo_expectation) From e9495541d2f4fb7f6f2cd1946568c4de2260055a Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 9 Jan 2025 10:12:08 +0100 Subject: [PATCH 83/88] simplify util.py --- python/ffsim/tenpy/__init__.py | 2 +- python/ffsim/tenpy/gates/__init__.py | 2 +- python/ffsim/tenpy/gates/abstract_gates.py | 2 +- python/ffsim/tenpy/gates/basic_gates.py | 6 +++--- python/ffsim/tenpy/gates/diag_coulomb.py | 2 +- python/ffsim/tenpy/gates/orbital_rotation.py | 2 +- python/ffsim/tenpy/gates/ucj.py | 2 +- python/ffsim/tenpy/hamiltonians/__init__.py | 2 +- .../tenpy/hamiltonians/molecular_hamiltonian.py | 2 +- python/ffsim/tenpy/util.py | 13 +++++-------- tests/python/tenpy/__init__.py | 2 +- tests/python/tenpy/gates/__init__.py | 2 +- tests/python/tenpy/gates/basic_gates_test.py | 2 +- tests/python/tenpy/gates/diag_coulomb_test.py | 2 +- tests/python/tenpy/gates/orbital_rotation_test.py | 2 +- tests/python/tenpy/gates/ucj_test.py | 2 +- .../hamiltonians/molecular_hamiltonian_test.py | 2 +- 17 files changed, 23 insertions(+), 26 deletions(-) diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index ba7306498..3762af710 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/gates/__init__.py b/python/ffsim/tenpy/gates/__init__.py index 5f2c9d9c1..7918d6a4b 100644 --- a/python/ffsim/tenpy/gates/__init__.py +++ b/python/ffsim/tenpy/gates/__init__.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/gates/abstract_gates.py b/python/ffsim/tenpy/gates/abstract_gates.py index 10b505819..801504cb0 100644 --- a/python/ffsim/tenpy/gates/abstract_gates.py +++ b/python/ffsim/tenpy/gates/abstract_gates.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/gates/basic_gates.py b/python/ffsim/tenpy/gates/basic_gates.py index a52afaa1d..dd56107fa 100644 --- a/python/ffsim/tenpy/gates/basic_gates.py +++ b/python/ffsim/tenpy/gates/basic_gates.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory @@ -79,7 +79,7 @@ def givens_rotation( # Ggate_a = ( # np.kron(sp.linalg.expm(1j * phi * Nu), Id) # @ sp.linalg.expm( - # theta * (np.kron(Cdu @ JWd, Cu @ Id) - np.kron(Cu @ JWd, Cdu @ Id)) + # theta * (np.kron(Cdu @ JWd, Cu) - np.kron(Cu @ JWd, Cdu)) # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nu), Id) # ) @@ -101,7 +101,7 @@ def givens_rotation( # Ggate_b = ( # np.kron(sp.linalg.expm(1j * phi * Nd), Id) # @ sp.linalg.expm( - # theta * (np.kron(Cdd @ JWu, Cd @ Id) - np.kron(Cd @ JWu, Cdd @ Id)) + # theta * (np.kron(Cdd @ JWu, Cd) - np.kron(Cd @ JWu, Cdd)) # ) # @ np.kron(sp.linalg.expm(-1j * phi * Nd), Id) # ) diff --git a/python/ffsim/tenpy/gates/diag_coulomb.py b/python/ffsim/tenpy/gates/diag_coulomb.py index 433b336c7..adb882d05 100644 --- a/python/ffsim/tenpy/gates/diag_coulomb.py +++ b/python/ffsim/tenpy/gates/diag_coulomb.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/gates/orbital_rotation.py b/python/ffsim/tenpy/gates/orbital_rotation.py index 92daa63bc..7adf4902c 100644 --- a/python/ffsim/tenpy/gates/orbital_rotation.py +++ b/python/ffsim/tenpy/gates/orbital_rotation.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/gates/ucj.py b/python/ffsim/tenpy/gates/ucj.py index ddd43c771..e3b740fa1 100644 --- a/python/ffsim/tenpy/gates/ucj.py +++ b/python/ffsim/tenpy/gates/ucj.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/hamiltonians/__init__.py b/python/ffsim/tenpy/hamiltonians/__init__.py index d734edb66..c1021d8a5 100644 --- a/python/ffsim/tenpy/hamiltonians/__init__.py +++ b/python/ffsim/tenpy/hamiltonians/__init__.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index bff91b1c0..83f58d740 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index cadf4ac00..817409e0c 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory @@ -34,7 +34,7 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: string_b = format(int_b, f"0{norb}b") # relabel using TeNPy SpinHalfFermionSite convention - product_state, swap_factors = [], [] + product_state, swap_factor = [], 1 for i, site in enumerate(zip(reversed(string_a), reversed(string_b))): if site == ("0", "0"): product_state.append("empty") @@ -50,9 +50,7 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: "down", "full", ]: - swap_factors.append(-1) - else: - swap_factors.append(1) + swap_factor *= -1 # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") @@ -62,8 +60,7 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: minus_identity_npc = npc.Array.from_ndarray( -shfs.get_op("Id").to_ndarray(), [shfs.leg, shfs.leg.conj()], labels=["p", "p*"] ) - for i, swap_factor in enumerate(swap_factors): - if swap_factor == -1: - mps.apply_local_op(i, minus_identity_npc) + if swap_factor == -1: + mps.apply_local_op(0, minus_identity_npc) return mps diff --git a/tests/python/tenpy/__init__.py b/tests/python/tenpy/__init__.py index 5f2c9d9c1..7918d6a4b 100644 --- a/tests/python/tenpy/__init__.py +++ b/tests/python/tenpy/__init__.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/gates/__init__.py b/tests/python/tenpy/gates/__init__.py index 5f2c9d9c1..7918d6a4b 100644 --- a/tests/python/tenpy/gates/__init__.py +++ b/tests/python/tenpy/gates/__init__.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index 917c46fa9..dafe52b5f 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py index ee85a684e..65597aa96 100644 --- a/tests/python/tenpy/gates/diag_coulomb_test.py +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index 218da7ed4..d8ee9e2f5 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/gates/ucj_test.py b/tests/python/tenpy/gates/ucj_test.py index ffdd559bc..6dae0fb8b 100644 --- a/tests/python/tenpy/gates/ucj_test.py +++ b/tests/python/tenpy/gates/ucj_test.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index ea3dbd115..8091e3f28 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -1,4 +1,4 @@ -# (C) Copyright IBM 2024. +# (C) Copyright IBM 2025. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory From 3187c7ad3772fe0cae1a72c18ff10cc6360492da Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 9 Jan 2025 11:08:30 +0100 Subject: [PATCH 84/88] add util_test.py --- tests/python/tenpy/util_test.py | 62 +++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 tests/python/tenpy/util_test.py diff --git a/tests/python/tenpy/util_test.py b/tests/python/tenpy/util_test.py new file mode 100644 index 000000000..6d435eed6 --- /dev/null +++ b/tests/python/tenpy/util_test.py @@ -0,0 +1,62 @@ +# (C) Copyright IBM 2025. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import numpy as np +import pytest +import tenpy.linalg.np_conserved as npc +from tenpy.networks.mps import MPS +from tenpy.networks.site import SpinHalfFermionSite + +from ffsim.tenpy.util import bitstring_to_mps + + +@pytest.mark.parametrize( + "bitstring, norb, product_state", + [ + ((0, 0), 2, [0, 0]), + ((2, 0), 2, [0, 1]), + ((0, 2), 2, [0, 2]), + ((2, 2), 2, [0, 3]), + ((1, 0), 2, [1, 0]), + ((3, 0), 2, [1, 1]), + ((1, 2), 2, [1, 2]), + ((3, 2), 2, [1, 3]), + ((0, 1), 2, [2, 0]), + ((2, 1), 2, [2, 1]), + ((0, 3), 2, [2, 2]), + ((2, 3), 2, [2, 3]), + ((1, 1), 2, [3, 0]), + ((3, 1), 2, [3, 1]), + ((1, 3), 2, [3, 2]), + ((3, 3), 2, [3, 3]), + ], +) +def test_bitstring_to_mps(bitstring: tuple[int, int], norb: int, product_state: list): + """Test converting a bitstring to an MPS.""" + + # convert bitstring to MPS + mps = bitstring_to_mps(bitstring, norb) + + # construct expected MPS + shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") + expected_mps = MPS.from_product_state([shfs] * norb, product_state) + + # map from ffsim to TeNPy ordering + if product_state[0] in [2, 3] and product_state[1] in [1, 3]: + minus_identity_npc = npc.Array.from_ndarray( + -shfs.get_op("Id").to_ndarray(), + [shfs.leg, shfs.leg.conj()], + labels=["p", "p*"], + ) + expected_mps.apply_local_op(0, minus_identity_npc) + + # test overlap is one + overlap = mps.overlap(expected_mps) + np.testing.assert_equal(overlap, 1) From 5f8cf926299e6dee017f9a3fdb42f5ee353a4cc3 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Thu, 9 Jan 2025 15:05:01 +0100 Subject: [PATCH 85/88] implement PR corrections --- python/ffsim/tenpy/util.py | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 817409e0c..c0e423da7 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -34,33 +34,30 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: string_b = format(int_b, f"0{norb}b") # relabel using TeNPy SpinHalfFermionSite convention - product_state, swap_factor = [], 1 + product_state = [] + swap_factor = 1 + occupation = {"00": 0, "10": 1, "01": 2, "11": 3} + previous_site_occupation = None for i, site in enumerate(zip(reversed(string_a), reversed(string_b))): - if site == ("0", "0"): - product_state.append("empty") - elif site == ("1", "0"): - product_state.append("up") - elif site == ("0", "1"): - product_state.append("down") - else: # site == ("1", "1"): - product_state.append("full") + site_occupation = occupation["".join(site)] + product_state.append(site_occupation) - if i > 0: - if product_state[-1] in ["up", "full"] and product_state[-2] in [ - "down", - "full", - ]: - swap_factor *= -1 + if site_occupation in [1, 3] and previous_site_occupation in [2, 3]: + swap_factor *= -1 + + previous_site_occupation = site_occupation # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") mps = MPS.from_product_state([shfs] * norb, product_state) # map from ffsim to TeNPy ordering - minus_identity_npc = npc.Array.from_ndarray( - -shfs.get_op("Id").to_ndarray(), [shfs.leg, shfs.leg.conj()], labels=["p", "p*"] - ) if swap_factor == -1: + minus_identity_npc = npc.Array.from_ndarray( + -shfs.get_op("Id").to_ndarray(), + [shfs.leg, shfs.leg.conj()], + labels=["p", "p*"], + ) mps.apply_local_op(0, minus_identity_npc) return mps From 003c15d556065982d7dcd7ec4528767a3eb71caa Mon Sep 17 00:00:00 2001 From: bartandrews Date: Fri, 10 Jan 2025 14:47:49 +0100 Subject: [PATCH 86/88] implement PR corrections 2 --- python/ffsim/tenpy/util.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index c0e423da7..3ed2d326e 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -36,13 +36,12 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: # relabel using TeNPy SpinHalfFermionSite convention product_state = [] swap_factor = 1 - occupation = {"00": 0, "10": 1, "01": 2, "11": 3} previous_site_occupation = None - for i, site in enumerate(zip(reversed(string_a), reversed(string_b))): - site_occupation = occupation["".join(site)] + for i, site in enumerate(zip(reversed(string_b), reversed(string_a))): + site_occupation = int("".join(site), base=2) product_state.append(site_occupation) - if site_occupation in [1, 3] and previous_site_occupation in [2, 3]: + if site_occupation in [0b01, 0b11] and previous_site_occupation in [0b10, 0b11]: swap_factor *= -1 previous_site_occupation = site_occupation From dd551ef5318014eb43552d29d7f014e04302aff5 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Wed, 15 Jan 2025 14:14:17 +0100 Subject: [PATCH 87/88] use random state vector and MPS for tests --- python/ffsim/tenpy/__init__.py | 6 +- python/ffsim/tenpy/random/__init__.py | 9 + python/ffsim/tenpy/random/random.py | 57 +++++ python/ffsim/tenpy/util.py | 200 +++++++++++++++++- tests/python/tenpy/gates/basic_gates_test.py | 98 +++------ tests/python/tenpy/gates/diag_coulomb_test.py | 26 +-- .../tenpy/gates/orbital_rotation_test.py | 26 +-- .../molecular_hamiltonian_test.py | 1 + tests/python/tenpy/util_test.py | 114 +++++++++- 9 files changed, 424 insertions(+), 113 deletions(-) create mode 100644 python/ffsim/tenpy/random/__init__.py create mode 100644 python/ffsim/tenpy/random/random.py diff --git a/python/ffsim/tenpy/__init__.py b/python/ffsim/tenpy/__init__.py index 3762af710..eb374aaa2 100644 --- a/python/ffsim/tenpy/__init__.py +++ b/python/ffsim/tenpy/__init__.py @@ -24,7 +24,8 @@ from ffsim.tenpy.gates.orbital_rotation import apply_orbital_rotation from ffsim.tenpy.gates.ucj import apply_ucj_op_spin_balanced from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import bitstring_to_mps +from ffsim.tenpy.random.random import random_mps +from ffsim.tenpy.util import bitstring_to_mps, mps_to_statevector, statevector_to_mps __all__ = [ "apply_ucj_op_spin_balanced", @@ -35,7 +36,10 @@ "bitstring_to_mps", "givens_rotation", "MolecularHamiltonianMPOModel", + "mps_to_statevector", "num_interaction", "num_num_interaction", "on_site_interaction", + "random_mps", + "statevector_to_mps", ] diff --git a/python/ffsim/tenpy/random/__init__.py b/python/ffsim/tenpy/random/__init__.py new file mode 100644 index 000000000..7918d6a4b --- /dev/null +++ b/python/ffsim/tenpy/random/__init__.py @@ -0,0 +1,9 @@ +# (C) Copyright IBM 2025. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/python/ffsim/tenpy/random/random.py b/python/ffsim/tenpy/random/random.py new file mode 100644 index 000000000..cc23396ec --- /dev/null +++ b/python/ffsim/tenpy/random/random.py @@ -0,0 +1,57 @@ +# (C) Copyright IBM 2025. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from tenpy.algorithms.tebd import RandomUnitaryEvolution +from tenpy.networks.mps import MPS + +import ffsim +from ffsim.tenpy.util import bitstring_to_mps + + +def random_mps( + norb: int, nelec: tuple[int, int], n_steps: int = 10, chi_max: int = 100 +) -> MPS: + """Return a random MPS generated from a random unitary evolution. + + Args: + norb: The number of orbitals. + nelec: The number of electrons. + n_steps: The number of steps in the random unitary evolution. + chi_max: The maximum bond dimension in the random unitary evolution. + + Returns: + The random MPS. + """ + + # initialize Hartree-Fock state + dim = ffsim.dim(norb, nelec) + strings = ffsim.addresses_to_strings( + range(dim), norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING + ) + string_tuples = [ + ( + int(string[len(string) // 2 :], base=2), + int(string[: len(string) // 2], base=2), + ) + for string in strings + ] + mps = bitstring_to_mps(string_tuples[0], norb) + + # apply random unitary evolution + tebd_params = { + "N_steps": n_steps, + "trunc_params": {"chi_max": chi_max}, + "verbose": 0, + } + eng = RandomUnitaryEvolution(mps, tebd_params) + eng.run() + mps.canonical_form() + + return mps diff --git a/python/ffsim/tenpy/util.py b/python/ffsim/tenpy/util.py index 3ed2d326e..dd5811e99 100644 --- a/python/ffsim/tenpy/util.py +++ b/python/ffsim/tenpy/util.py @@ -12,9 +12,16 @@ from __future__ import annotations +from copy import deepcopy + +import numpy as np import tenpy.linalg.np_conserved as npc +from tenpy.algorithms.exact_diag import ExactDiag +from tenpy.models.model import MPOModel from tenpy.networks.mps import MPS -from tenpy.networks.site import SpinHalfFermionSite +from tenpy.networks.site import FermionSite, SpinHalfFermionSite + +import ffsim def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: @@ -35,22 +42,34 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: # relabel using TeNPy SpinHalfFermionSite convention product_state = [] - swap_factor = 1 - previous_site_occupation = None for i, site in enumerate(zip(reversed(string_b), reversed(string_a))): site_occupation = int("".join(site), base=2) product_state.append(site_occupation) - if site_occupation in [0b01, 0b11] and previous_site_occupation in [0b10, 0b11]: - swap_factor *= -1 - - previous_site_occupation = site_occupation - # construct product state MPS shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") mps = MPS.from_product_state([shfs] * norb, product_state) - # map from ffsim to TeNPy ordering + # map from TeNPy to ffsim ordering + fs = FermionSite(conserve="N") + alpha_sector = mps.expectation_value("Nu") + beta_sector = mps.expectation_value("Nd") + product_state_fs_tenpy = [ + int(val) for pair in zip(alpha_sector, beta_sector) for val in pair + ] + mps_fs = MPS.from_product_state([fs] * 2 * norb, product_state_fs_tenpy) + + tenpy_ordering = list(range(2 * norb)) + midpoint = len(tenpy_ordering) // 2 + mask1 = tenpy_ordering[:midpoint][::-1] + mask2 = tenpy_ordering[midpoint:][::-1] + ffsim_ordering = [int(val) for pair in zip(mask1, mask2) for val in pair] + + mps_ref = deepcopy(mps_fs) + mps_ref.permute_sites(ffsim_ordering, swap_op=None) + mps_fs.permute_sites(ffsim_ordering, swap_op="auto") + swap_factor = mps_fs.overlap(mps_ref) + if swap_factor == -1: minus_identity_npc = npc.Array.from_ndarray( -shfs.get_op("Id").to_ndarray(), @@ -60,3 +79,166 @@ def bitstring_to_mps(bitstring: tuple[int, int], norb: int) -> MPS: mps.apply_local_op(0, minus_identity_npc) return mps + + +def mps_to_statevector(mps: MPS, mpo_model: MPOModel) -> np.ndarray: + r"""Return the MPS as a state vector. + + Args: + mps: The MPS. + mpo_model: The MPO model. + + Returns: + The state vector. + """ + + # generate the (ffsim-ordered) list of product states + norb = mps.L + n_alpha = round(np.sum(mps.expectation_value("Nu"))) + n_beta = round(np.sum(mps.expectation_value("Nd"))) + nelec = (n_alpha, n_beta) + product_states = _generate_product_states(norb, nelec) + + # initialize the TeNPy ExactDiag class instance + charge_sector = mps.get_total_charge(True) + exact_diag = ExactDiag(mpo_model, charge_sector=charge_sector) + + # determine the mapping from TeNPy basis to ffsim basis + basis_ordering_ffsim, swap_factors_ffsim = _map_tenpy_to_ffsim_basis( + product_states, exact_diag, norb + ) + + # convert TeNPy MPS to ffsim statevector + statevector = exact_diag.mps_to_full(mps).to_ndarray() + statevector = np.multiply(swap_factors_ffsim, statevector[basis_ordering_ffsim]) + + return statevector + + +def statevector_to_mps( + statevector: np.ndarray, mpo_model: MPOModel, norb: int, nelec: tuple[int, int] +) -> MPS: + r"""Return the state vector as an MPS. + + Args: + statevector: The state vector. + mpo_model: The MPO model. + norb: The number of orbitals. + nelec: The number of electrons. + + Returns: + The MPS. + """ + + # generate the (ffsim-ordered) list of product states + product_states = _generate_product_states(norb, nelec) + + # initialize the TeNPy ExactDiag class instance + mps_reference = MPS.from_product_state(mpo_model.lat.mps_sites(), product_states[0]) + charge_sector = mps_reference.get_total_charge(True) + exact_diag = ExactDiag(mpo_model, charge_sector=charge_sector) + statevector_reference = exact_diag.mps_to_full(mps_reference) + leg_charge = statevector_reference.legs[0] + + # determine the mapping from ffsim basis to TeNPy basis + basis_ordering_ffsim, swap_factors_ffsim = _map_tenpy_to_ffsim_basis( + product_states, exact_diag, norb + ) + basis_ordering_tenpy = np.argsort(basis_ordering_ffsim) + swap_factors_tenpy = swap_factors_ffsim[np.argsort(basis_ordering_ffsim)] + + # convert ffsim statevector to TeNPy MPS + statevector = np.multiply(swap_factors_tenpy, statevector[basis_ordering_tenpy]) + statevector_npc = npc.Array.from_ndarray(statevector, [leg_charge]) + mps = exact_diag.full_to_mps(statevector_npc) + + return mps + + +def _generate_product_states(norb: int, nelec: tuple[int, int]) -> list: + r"""Generate the ffsim-ordered list of product states in TeNPy notation. + + Args: + norb: The number of orbitals. + nelec: The number of electrons. + + Returns: + The ffsim-ordered list of product states in TeNPy notation. + """ + + # generate the strings + dim = ffsim.dim(norb, nelec) + strings = ffsim.addresses_to_strings( + range(dim), norb=norb, nelec=nelec, bitstring_type=ffsim.BitstringType.STRING + ) + string_tuples = [ + ( + int(string[len(string) // 2 :], base=2), + int(string[: len(string) // 2], base=2), + ) + for string in strings + ] + + # convert strings to product states + product_states = [] + for bitstring in string_tuples: + # unpack bitstrings + int_a, int_b = bitstring + string_a = format(int_a, f"0{norb}b") + string_b = format(int_b, f"0{norb}b") + + # relabel using TeNPy SpinHalfFermionSite convention + product_state = [] + for i, site in enumerate(zip(reversed(string_b), reversed(string_a))): + site_occupation = int("".join(site), base=2) + product_state.append(site_occupation) + product_states.append(product_state) + + return product_states + + +def _map_tenpy_to_ffsim_basis( + product_states: list, exact_diag: ExactDiag, norb: int +) -> tuple[np.ndarray, np.ndarray]: + r"""Map from the TeNPy basis to the ffsim basis. + + Args: + product_states: The ffsim-ordered list of product states in TeNPy notation. + exact_diag: The TeNPy ExactDiag class instance. + norb: The number of orbitals. + + Returns: + basis_ordering_ffsim: The permutation to map from the TeNPy to ffsim basis. + swap_factors: The minus signs that are introduced due to this mapping. + """ + + basis_ordering_ffsim = [] + swap_factors = [] + for i, state in enumerate(product_states): + # basis_ordering_ffsim + prod_mps = MPS.from_product_state(exact_diag.model.lat.mps_sites(), state) + prod_statevector = list(exact_diag.mps_to_full(prod_mps).to_ndarray()) + idx = prod_statevector.index(1) + basis_ordering_ffsim.append(idx) + + # swap_factors + fs = FermionSite(conserve="N") + alpha_sector = prod_mps.expectation_value("Nu") + beta_sector = prod_mps.expectation_value("Nd") + product_state_fs_tenpy = [ + int(val) for pair in zip(alpha_sector, beta_sector) for val in pair + ] + mps_fs = MPS.from_product_state([fs] * 2 * norb, product_state_fs_tenpy) + # + tenpy_ordering = list(range(2 * norb)) + midpoint = len(tenpy_ordering) // 2 + mask1 = tenpy_ordering[:midpoint][::-1] + mask2 = tenpy_ordering[midpoint:][::-1] + ffsim_ordering = [int(val) for pair in zip(mask1, mask2) for val in pair] + # + mps_ref = deepcopy(mps_fs) + mps_ref.permute_sites(ffsim_ordering, swap_op=None) + mps_fs.permute_sites(ffsim_ordering, swap_op="auto") + swap_factors.append(mps_fs.overlap(mps_ref)) + + return np.array(basis_ordering_ffsim), np.array(swap_factors) diff --git a/tests/python/tenpy/gates/basic_gates_test.py b/tests/python/tenpy/gates/basic_gates_test.py index dafe52b5f..74320581d 100644 --- a/tests/python/tenpy/gates/basic_gates_test.py +++ b/tests/python/tenpy/gates/basic_gates_test.py @@ -25,7 +25,7 @@ on_site_interaction, ) from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import bitstring_to_mps +from ffsim.tenpy.util import statevector_to_mps @pytest.mark.parametrize( @@ -49,22 +49,6 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): """Test applying a Givens rotation gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -75,6 +59,14 @@ def test_givens_rotation(norb: int, nelec: tuple[int, int], spin: Spin): ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate random Givens rotation parameters theta = 2 * np.pi * rng.random() phi = 2 * np.pi * rng.random() @@ -117,22 +109,6 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): """Test applying a number interaction gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -143,6 +119,14 @@ def test_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate random number interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb) @@ -177,22 +161,6 @@ def test_on_site_interaction( """Test applying an on-site interaction gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -203,6 +171,14 @@ def test_on_site_interaction( ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate random on-site interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb) @@ -242,22 +218,6 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): """Test applying a number-number interaction gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -268,6 +228,14 @@ def test_num_num_interaction(norb: int, nelec: tuple[int, int], spin: Spin): ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate random number-number interaction parameters theta = 2 * np.pi * rng.random() p = rng.integers(0, norb - 1) diff --git a/tests/python/tenpy/gates/diag_coulomb_test.py b/tests/python/tenpy/gates/diag_coulomb_test.py index 65597aa96..b379fce3d 100644 --- a/tests/python/tenpy/gates/diag_coulomb_test.py +++ b/tests/python/tenpy/gates/diag_coulomb_test.py @@ -18,7 +18,7 @@ import ffsim from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import bitstring_to_mps +from ffsim.tenpy.util import statevector_to_mps @pytest.mark.parametrize( @@ -34,22 +34,6 @@ def test_apply_diag_coulomb_evolution(norb: int, nelec: tuple[int, int]): """Test applying a diagonal Coulomb evolution gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -60,6 +44,14 @@ def test_apply_diag_coulomb_evolution(norb: int, nelec: tuple[int, int]): ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate random diagonal Coulomb evolution parameters mat_aa = np.diag(rng.standard_normal(norb - 1), k=-1) mat_aa += mat_aa.T diff --git a/tests/python/tenpy/gates/orbital_rotation_test.py b/tests/python/tenpy/gates/orbital_rotation_test.py index d8ee9e2f5..c094692d1 100644 --- a/tests/python/tenpy/gates/orbital_rotation_test.py +++ b/tests/python/tenpy/gates/orbital_rotation_test.py @@ -18,7 +18,7 @@ import ffsim from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel -from ffsim.tenpy.util import bitstring_to_mps +from ffsim.tenpy.util import statevector_to_mps @pytest.mark.parametrize( @@ -37,22 +37,6 @@ def test_apply_orbital_rotation( """Test applying an orbital rotation gate to an MPS.""" rng = np.random.default_rng() - # generate a random product state - dim = ffsim.dim(norb, nelec) - idx = rng.integers(0, high=dim) - original_vec = ffsim.linalg.one_hot(dim, idx) - - # convert random product state to MPS - strings_a, strings_b = ffsim.addresses_to_strings( - [idx], - norb=norb, - nelec=nelec, - bitstring_type=ffsim.BitstringType.STRING, - concatenate=False, - ) - mps = bitstring_to_mps((int(strings_a[0], 2), int(strings_b[0], 2)), norb) - original_mps = deepcopy(mps) - # generate a random molecular Hamiltonian mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) @@ -63,6 +47,14 @@ def test_apply_orbital_rotation( ) mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + # generate a random state vector + dim = ffsim.dim(norb, nelec) + original_vec = ffsim.random.random_state_vector(dim, seed=rng) + + # convert random state vector to MPS + mps = statevector_to_mps(original_vec, mol_hamiltonian_mpo_model, norb, nelec) + original_mps = deepcopy(mps) + # generate a random orbital rotation mat = ffsim.random.random_unitary(norb, seed=rng) diff --git a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py index 8091e3f28..87238472c 100644 --- a/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py +++ b/tests/python/tenpy/hamiltonians/molecular_hamiltonian_test.py @@ -29,6 +29,7 @@ (2, (1, 1)), (2, (0, 2)), (2, (0, 0)), + (3, (2, 2)), ], ) def test_from_molecular_hamiltonian(norb: int, nelec: tuple[int, int]): diff --git a/tests/python/tenpy/util_test.py b/tests/python/tenpy/util_test.py index 6d435eed6..21408ee89 100644 --- a/tests/python/tenpy/util_test.py +++ b/tests/python/tenpy/util_test.py @@ -8,13 +8,18 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +from copy import deepcopy + import numpy as np import pytest import tenpy.linalg.np_conserved as npc from tenpy.networks.mps import MPS -from tenpy.networks.site import SpinHalfFermionSite +from tenpy.networks.site import FermionSite, SpinHalfFermionSite -from ffsim.tenpy.util import bitstring_to_mps +import ffsim +from ffsim.tenpy.hamiltonians.molecular_hamiltonian import MolecularHamiltonianMPOModel +from ffsim.tenpy.random.random import random_mps +from ffsim.tenpy.util import bitstring_to_mps, mps_to_statevector, statevector_to_mps @pytest.mark.parametrize( @@ -36,6 +41,7 @@ ((3, 1), 2, [3, 1]), ((1, 3), 2, [3, 2]), ((3, 3), 2, [3, 3]), + ((5, 6), 3, [1, 2, 3]), ], ) def test_bitstring_to_mps(bitstring: tuple[int, int], norb: int, product_state: list): @@ -48,8 +54,27 @@ def test_bitstring_to_mps(bitstring: tuple[int, int], norb: int, product_state: shfs = SpinHalfFermionSite(cons_N="N", cons_Sz="Sz") expected_mps = MPS.from_product_state([shfs] * norb, product_state) - # map from ffsim to TeNPy ordering - if product_state[0] in [2, 3] and product_state[1] in [1, 3]: + # map from TeNPy to ffsim ordering + fs = FermionSite(conserve="N") + alpha_sector = mps.expectation_value("Nu") + beta_sector = mps.expectation_value("Nd") + product_state_fs_tenpy = [ + int(val) for pair in zip(alpha_sector, beta_sector) for val in pair + ] + mps_fs = MPS.from_product_state([fs] * 2 * norb, product_state_fs_tenpy) + + tenpy_ordering = list(range(2 * norb)) + midpoint = len(tenpy_ordering) // 2 + mask1 = tenpy_ordering[:midpoint][::-1] + mask2 = tenpy_ordering[midpoint:][::-1] + ffsim_ordering = [int(val) for pair in zip(mask1, mask2) for val in pair] + + mps_ref = deepcopy(mps_fs) + mps_ref.permute_sites(ffsim_ordering, swap_op=None) + mps_fs.permute_sites(ffsim_ordering, swap_op="auto") + swap_factor = mps_fs.overlap(mps_ref) + + if swap_factor == -1: minus_identity_npc = npc.Array.from_ndarray( -shfs.get_op("Id").to_ndarray(), [shfs.leg, shfs.leg.conj()], @@ -60,3 +85,84 @@ def test_bitstring_to_mps(bitstring: tuple[int, int], norb: int, product_state: # test overlap is one overlap = mps.overlap(expected_mps) np.testing.assert_equal(overlap, 1) + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (2, (2, 2)), + (2, (2, 1)), + (2, (1, 2)), + (2, (1, 1)), + (2, (0, 2)), + (2, (0, 0)), + (3, (2, 2)), + ], +) +def test_mps_to_statevector(norb: int, nelec: tuple[int, int]): + """Test converting an MPS to a statevector.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random MPS + mps = random_mps(norb, nelec) + + # convert MPS to statevector + statevector = mps_to_statevector(mps, mol_hamiltonian_mpo_model) + + # test expectation is preserved + original_expectation = np.vdot(statevector, hamiltonian @ statevector) + mps_original = deepcopy(mps) + mol_hamiltonian_mpo.apply_naively(mps) + mpo_expectation = mps_original.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) + + +@pytest.mark.parametrize( + "norb, nelec", + [ + (2, (2, 2)), + (2, (2, 1)), + (2, (1, 2)), + (2, (1, 1)), + (2, (0, 2)), + (2, (0, 0)), + (3, (2, 2)), + ], +) +def test_statevector_to_mps(norb: int, nelec: tuple[int, int]): + """Test converting a statevector to an MPS.""" + rng = np.random.default_rng() + + # generate a random molecular Hamiltonian + mol_hamiltonian = ffsim.random.random_molecular_hamiltonian(norb, seed=rng) + hamiltonian = ffsim.linear_operator(mol_hamiltonian, norb, nelec) + + # convert molecular Hamiltonian to MPO + mol_hamiltonian_mpo_model = MolecularHamiltonianMPOModel.from_molecular_hamiltonian( + mol_hamiltonian + ) + mol_hamiltonian_mpo = mol_hamiltonian_mpo_model.H_MPO + + # generate a random statevector + dim = ffsim.dim(norb, nelec) + statevector = ffsim.random.random_state_vector(dim, seed=rng) + + # convert statevector to MPS + mps = statevector_to_mps(statevector, mol_hamiltonian_mpo_model, norb, nelec) + + # test expectation is preserved + original_expectation = np.vdot(statevector, hamiltonian @ statevector) + mps_original = deepcopy(mps) + mol_hamiltonian_mpo.apply_naively(mps) + mpo_expectation = mps_original.overlap(mps) + np.testing.assert_allclose(original_expectation, mpo_expectation) From e352701e273904300bc88dfacae23c0e0375ce07 Mon Sep 17 00:00:00 2001 From: bartandrews Date: Wed, 15 Jan 2025 15:22:34 +0100 Subject: [PATCH 88/88] reintroduce optimized loops for constructing Hamiltonian MPO --- .../hamiltonians/molecular_hamiltonian.py | 106 +++++++++++------- 1 file changed, 68 insertions(+), 38 deletions(-) diff --git a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py index 83f58d740..e4ec964e9 100644 --- a/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py +++ b/python/ffsim/tenpy/hamiltonians/molecular_hamiltonian.py @@ -67,47 +67,77 @@ def init_terms(self, params) -> None: ) constant = params.get("constant", 0, expect_type="real") - # constant for p in range(self.norb): + # one-body tensor + h1 = self.one_body_tensor[p, p] + self.add_onsite(h1, p, "Ntot") + # two-body tensor + h2 = two_body_tensor[p, p, p, p] + self.add_onsite(h2, p, "Ntot") + self.add_onsite(-0.5 * h2, p, "Nu Nu") + self.add_onsite(-0.5 * h2, p, "Cdu Cd Cdd Cu") + self.add_onsite(-0.5 * h2, p, "Cdd Cu Cdu Cd") + self.add_onsite(-0.5 * h2, p, "Nd Nd") + # constant self.add_onsite(constant / self.norb, p, "Id") - # one-body terms - for p, q in itertools.product(range(self.norb), repeat=2): - self._add_one_body(self.one_body_tensor[p, q], p, q) - - # two-body terms - for p, q, r, s in itertools.product(range(self.norb), repeat=4): - self._add_two_body(0.5 * two_body_tensor[p, q, r, s], p, q, r, s) - - def _add_one_body(self, coeff: complex, p: int, q: int) -> None: - if p == q: - self.add_onsite(coeff, p, "Ntot") - else: - dx0 = np.zeros(2) - self.add_coupling(coeff, p, "Cdu", q, "Cu", dx0) - self.add_coupling(coeff, p, "Cdd", q, "Cd", dx0) - - def _add_two_body(self, coeff: complex, p: int, q: int, r: int, s: int) -> None: - if p == q == r == s: - self.add_onsite(2 * coeff, p, "Nu Nd") - else: - dx0 = np.zeros(2) - self.add_multi_coupling( - coeff, - [("Cdu", dx0, p), ("Cdu", dx0, r), ("Cu", dx0, s), ("Cu", dx0, q)], - ) - self.add_multi_coupling( - coeff, - [("Cdu", dx0, p), ("Cdd", dx0, r), ("Cd", dx0, s), ("Cu", dx0, q)], - ) - self.add_multi_coupling( - coeff, - [("Cdd", dx0, p), ("Cdu", dx0, r), ("Cu", dx0, s), ("Cd", dx0, q)], - ) - self.add_multi_coupling( - coeff, - [("Cdd", dx0, p), ("Cdd", dx0, r), ("Cd", dx0, s), ("Cd", dx0, q)], - ) + for p, q in itertools.combinations(range(self.norb), 2): + # one-body tensor + h1 = self.one_body_tensor[p, q] + self._add_one_body(h1, p, q, flag_hc=True) + # two-body tensor + indices = [(p, p, q, q), (p, q, p, q), (p, q, q, p)] + for i, j, k, ell in indices: + h2 = two_body_tensor[i, j, k, ell] + self._add_two_body(0.5 * h2, i, j, k, ell, flag_hc=True) + + for p, s in itertools.combinations_with_replacement(range(self.norb), 2): + for q, r in itertools.combinations_with_replacement(range(self.norb), 2): + values, counts = np.unique([p, q, r, s], return_counts=True) + if not (len(values) in [1, 2] and len(set(counts)) == 1): + # two-body tensor + indices = [(p, q, r, s)] + if p != s: + indices.append((s, q, r, p)) # swap p and s + if q != r: + indices.append((p, r, q, s)) # swap q and r + for idx, (i, j, k, ell) in enumerate(indices): + # reverse p, q, r, s by adding hermitian conjugate + flag_hc = True if not idx and i != ell and j != k else False + h2 = two_body_tensor[i, j, k, ell] + self._add_two_body(0.5 * h2, i, j, k, ell, flag_hc=flag_hc) + + def _add_one_body( + self, coeff: complex, i: int, j: int, flag_hc: bool = False + ) -> None: + dx0 = np.zeros(2) + self.add_coupling(coeff, i, "Cdu", j, "Cu", dx0, plus_hc=flag_hc) + self.add_coupling(coeff, i, "Cdd", j, "Cd", dx0, plus_hc=flag_hc) + + def _add_two_body( + self, coeff: complex, i: int, j: int, k: int, ell: int, flag_hc: bool = False + ) -> None: + dx0 = np.zeros(2) + self.add_multi_coupling( + coeff, + [("Cdu", dx0, i), ("Cdu", dx0, k), ("Cu", dx0, ell), ("Cu", dx0, j)], + plus_hc=flag_hc, + ) + self.add_multi_coupling( + coeff, + [("Cdu", dx0, i), ("Cdd", dx0, k), ("Cd", dx0, ell), ("Cu", dx0, j)], + plus_hc=flag_hc, + ) + self.add_multi_coupling( + coeff, + [("Cdd", dx0, i), ("Cdu", dx0, k), ("Cu", dx0, ell), ("Cd", dx0, j)], + plus_hc=flag_hc, + ) + self.add_multi_coupling( + coeff, + [("Cdd", dx0, i), ("Cdd", dx0, k), ("Cd", dx0, ell), ("Cd", dx0, j)], + plus_hc=flag_hc, + ) @staticmethod def from_molecular_hamiltonian(