From 98f342e4f20a4e1fa5ee72f1613e7838910febb4 Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Mon, 17 Jun 2024 17:04:40 +0200 Subject: [PATCH 1/9] fixed bugs; added notebook; still a mess --- examples/hydrogen_algorithm.py | 78 ++ examples/hydrogen_qiskit.ipynb | 941 +++++++++++++++++++++++ examples/hydrogen_qiskit.py | 81 +- examples/simple_vqe.py | 121 +++ quantuminspire/util/api/local_backend.py | 6 +- 5 files changed, 1208 insertions(+), 19 deletions(-) create mode 100644 examples/hydrogen_algorithm.py create mode 100644 examples/hydrogen_qiskit.ipynb create mode 100644 examples/simple_vqe.py diff --git a/examples/hydrogen_algorithm.py b/examples/hydrogen_algorithm.py new file mode 100644 index 00000000..713a284b --- /dev/null +++ b/examples/hydrogen_algorithm.py @@ -0,0 +1,78 @@ +from typing import Any +from quantuminspire.util.api.quantum_interface import QuantumInterface +import numpy as np + + +def execute(qi: QuantumInterface) -> None: + distances = np.arange(0.3, 2.5, 0.1) + results = [] + for distance in distances: + from qiskit_nature.second_q.drivers import PySCFDriver + + + molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" + driver = PySCFDriver(molecule) + es_problem = driver.run() + + fermionic_op = es_problem.hamiltonian.second_q_op() + n_particles = es_problem.num_particles + n_spatial_orbitals = es_problem.num_spatial_orbitals + nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy + + from qiskit_nature.second_q.mappers import ParityMapper + from qiskit_nature.second_q.mappers import JordanWignerMapper + + mapper = JordanWignerMapper() + qubit_op = mapper.map(fermionic_op) + + from qiskit.quantum_info import SparsePauliOp + + qubit_op = SparsePauliOp(["X", "Z"], coeffs=np.array([1, distance])) + nuclear_repulsion_energy = 0 + + from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD + + initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) + ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) + + from qiskit import QuantumCircuit + from qiskit.circuit import Parameter + params = [Parameter("t_0"), Parameter("t_1")] + + ansatz = QuantumCircuit(1) + ansatz.ry(params[0], qubit=0) + ansatz.rz(params[1], qubit=0) + + from qiskit.primitives import BackendEstimator + from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend + + backend = QuantumInspireBackend(qi) # qi is passed into `execute` + estimator = BackendEstimator(backend=backend) + + from qiskit_algorithms.optimizers import COBYLA + + optimizer = COBYLA(maxiter=100) + + from qiskit_algorithms import VQE + + algo = VQE(estimator, ansatz, optimizer) + result = algo.compute_minimum_eigenvalue(qubit_op) + + result_dict = {"distance": distance, "total_energy": result.eigenvalue + nuclear_repulsion_energy} + + from qiskit import transpile + + transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) + result_dict["circuit"] = repr(transpiled_circuit.draw()).replace("'", '"') + result_dict["circuit_depth"] = transpiled_circuit.depth() + result_dict["optimal_t_0"] = result.optimal_parameters[params[0]] + result_dict["optimal_t_1"] = result.optimal_parameters[params[1]] + + # result_dict["circuit"] = result.optimal_circuit.decompose(reps=20).draw("text") + results.append(result_dict) + + qi.results = {"results": results} + + +def finalize(results: Any) -> dict[str, Any]: + return results diff --git a/examples/hydrogen_qiskit.ipynb b/examples/hydrogen_qiskit.ipynb new file mode 100644 index 00000000..d2288faf --- /dev/null +++ b/examples/hydrogen_qiskit.ipynb @@ -0,0 +1,941 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Hydrogen algorithm for QAL Quantum Inspire hybrid computing workshop ", + "id": "b48c3683d38cabf" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Make a new empty Python file", + "id": "66d29b62f486f266" + }, + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-06-17T12:13:09.413470Z", + "start_time": "2024-06-17T12:13:09.204526Z" + } + }, + "source": [ + "from pathlib import Path\n", + "\n", + "filename = str(Path.cwd() / \"hydrogen_algorithm.py\") \n", + "!touch {filename}" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n" + ] + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Add an `execute` and a `finalize` function to the file with the following input arguments", + "id": "9e06c3bfbc525b76" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from typing import Any\n", + "from quantuminspire.util.api.quantum_interface import QuantumInterface\n", + "\n", + "\n", + "def execute(qi: QuantumInterface) -> None:\n", + " ...\n", + "\n", + "def finalize(results: Any) -> dict[str, Any]:\n", + " ..." + ], + "id": "8daaf3f52f28f96e" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Have the `execute` function add something to the results, and have `finalize` return them", + "id": "6614ddb463e43d1c" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from typing import Any\n", + "from quantuminspire.util.api.quantum_interface import QuantumInterface\n", + "\n", + "\n", + "def execute(qi: QuantumInterface) -> None:\n", + " qi.results = {\"results\": 2}\n", + "\n", + "def finalize(results: Any) -> dict[str, Any]:\n", + " return results" + ], + "id": "5999967ad19c277d" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Use the `print_output` function to execute the Python file and print its output", + "id": "bc44c6b00b985cd7" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-17T13:38:07.452718Z", + "start_time": "2024-06-17T13:37:48.117337Z" + } + }, + "cell_type": "code", + "source": [ + "def print_output():\n", + " output = !poetry run qi files run {filename}\n", + " print(output)\n", + " \n", + "print_output()" + ], + "id": "4031bb12fe6b4615", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.3, 'total_energy': 1.4865802864000002, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.450434622822838, 'optimal_t_1': 4.4214434387828305}, {'distance': 0.4, 'total_energy': 1.3952086523, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 6.192765932878906, 'optimal_t_1': -3.7698206453031022}, {'distance': 0.5, 'total_energy': 0.9939012968400001, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 0.06484530325044346, 'optimal_t_1': -3.1347833911582352}, {'distance': 0.6000000000000001, 'total_energy': 0.8643838932, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.308178940539449, 'optimal_t_1': 1.5947722559472224}, {'distance': 0.7000000000000002, 'total_energy': 0.32432681917142847, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 5.4133968705340045, 'optimal_t_1': 5.3111698206458655}, {'distance': 0.8000000000000003, 'total_energy': 0.5950652636499999, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.487358235890828, 'optimal_t_1': 1.6631224966426652}, {'distance': 0.9000000000000001, 'total_energy': 0.3614121788, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.952151286508921, 'optimal_t_1': -2.3425545376628776}, {'distance': 1.0000000000000002, 'total_energy': 0.4315209609199999, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -0.12433859380029322, 'optimal_t_1': 0.653287389810159}, {'distance': 1.1000000000000003, 'total_energy': 1.4127108167454545, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.783008108547035, 'optimal_t_1': 3.4516296666984925}, {'distance': 1.2000000000000004, 'total_energy': -0.3012064909000001, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.404402559250089, 'optimal_t_1': 3.407777863206878}, {'distance': 1.3000000000000005, 'total_energy': 0.44416876801538446, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.2206591336320312, 'optimal_t_1': 1.6101765814433087}, {'distance': 1.4000000000000004, 'total_energy': 0.10649934708571424, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.086286912278961, 'optimal_t_1': 4.370952198454573}, {'distance': 1.5000000000000004, 'total_energy': 0.82153480728, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.112973326613269, 'optimal_t_1': 2.1207005943201516}, {'distance': 1.6000000000000005, 'total_energy': 0.889329506825, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.020389080010611, 'optimal_t_1': -0.7604473956951798}, {'distance': 1.7000000000000004, 'total_energy': 0.7937025873058823, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -0.8223768024227915, 'optimal_t_1': 3.9938180460292543}, {'distance': 1.8000000000000005, 'total_energy': 0.22562796439999994, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.907014752663402, 'optimal_t_1': -4.411875898738632}, {'distance': 1.9000000000000006, 'total_energy': 0.637889321536842, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 1.0008465262372193, 'optimal_t_1': 1.1289165130082024}, {'distance': 2.0000000000000004, 'total_energy': -0.52642701954, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.2258030179644592, 'optimal_t_1': -3.076163042503146}, {'distance': 2.1000000000000005, 'total_energy': 0.6094110230571428, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -2.77542510895853, 'optimal_t_1': 3.2184027576366745}, {'distance': 2.2000000000000006, 'total_energy': -0.4352461541272728, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.6104117584643305, 'optimal_t_1': 0.8275302919839298}, {'distance': 2.3000000000000007, 'total_energy': -0.1781260767739131, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.203329156373638, 'optimal_t_1': -4.230668923664325}, {'distance': 2.4000000000000004, 'total_energy': 0.99392800455, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 4.026376152689799, 'optimal_t_1': -3.104746427529323}]}\"]\n" + ] + } + ], + "execution_count": 35 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "In the next couple of cells, we will be adding the hydrogen algorithm to the `execute` function. Add these commands to the function.\n", + "\n", + "Specify a molecule configuration with the distance between the atoms. Make a molecule driver from this, and use it to generate an ElectronicStructureProblem." + ], + "id": "1d27bafa8e78106a" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "\n", + "distance = 0.735\n", + "molecule = f\"H 0.0 0.0 0.0; H 0.0 0.0 {distance}\"\n", + "driver = PySCFDriver(molecule)\n", + "es_problem = driver.run()" + ], + "id": "b38435ca858dbfdc" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Get the fermionic (electronic creation and annihilation) operators and store some useful attributes for later ", + "id": "251ab265f723f139" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "fermionic_op = es_problem.hamiltonian.second_q_op()\n", + "n_particles = es_problem.num_particles\n", + "n_spatial_orbitals = es_problem.num_spatial_orbitals\n", + "nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy" + ], + "id": "477e8407a0431666" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Map the fermionic operators onto qubit operators", + "id": "6c7e16c0f2820b49" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit_nature.second_q.mappers import ParityMapper\n", + "\n", + "mapper = ParityMapper(num_particles=(1, 1))\n", + "qubit_op = mapper.map(fermionic_op)" + ], + "id": "fc33cb8697944cfc" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Make the ansatz from the initial state", + "id": "a1bf4fee6fd38098" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD\n", + "\n", + "initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper)\n", + "ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state)" + ], + "id": "1d3a53b494fc14f4" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Use Quantum Inspire's Qiskit backend to make the estimator", + "id": "7b158797c551827a" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit.primitives import BackendEstimator\n", + "from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend\n", + "\n", + "backend = QuantumInspireBackend(qi) # qi is passed into `execute`\n", + "estimator = BackendEstimator(backend=backend)" + ], + "id": "1fb2c8afaac72b5d" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Make the optimizer", + "id": "4239c37767049c0b" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit_algorithms.optimizers import COBYLA\n", + "\n", + "optimizer = COBYLA(maxiter=1)" + ], + "id": "728112b2b33aa466" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Put everything together to make the VQE algorithm, and run it to get the result", + "id": "31c9e48ce16f2142" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit_algorithms import VQE\n", + "\n", + "algo = VQE(estimator, ansatz, optimizer)\n", + "result = algo.compute_minimum_eigenvalue(qubit_op)" + ], + "id": "21c37beed3723f1c" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Replace the returned result with the distance and the total energy. The total energy is the sum of the eigenvalue calculated by the algorithm and the nuclear repulsion energy. ", + "id": "5632d24632222883" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "qi.results = {\"results\": [{\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}]}", + "id": "1748e8c980182c56" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Print the output to show the distance and the total energy", + "id": "4cbcdab535882a1c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T10:43:21.922122Z", + "start_time": "2024-06-14T10:43:14.426455Z" + } + }, + "cell_type": "code", + "source": "print_output()", + "id": "dcee350bc09a7064", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.735, 'total_energy': -0.3868728641492053}]}\"]\n" + ] + } + ], + "execution_count": 5 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Now that we can calculate the total energy for a single distance, let's vary the distance and see what happens.\n", + "\n", + "Wrap the entire body of the execute function in a for loop to loop over different distances, replacing the constant `distance`." + ], + "id": "a068b97588e58d8b" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "import numpy as np\n", + "\n", + "def execute(qi: QuantumInterface) -> None:\n", + " distances = np.arange(0.3, 2.5, 0.1)\n", + " results = []\n", + " for distance in distances:\n", + " ... # execute body\n", + " result_dict = {\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}\n", + " results.append(result_dict)\n", + " \n", + " qi.results = {\"results\": results}" + ], + "id": "fb84e1461cd3efcb" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Print the output to see the total energy for different distances", + "id": "3be6069522c094ba" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T10:57:33.948418Z", + "start_time": "2024-06-14T10:57:07.773340Z" + } + }, + "cell_type": "code", + "source": "print_output()", + "id": "378ee61864fa2526", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.3, 'total_energy': 0.6049237873477202}, {'distance': 0.4, 'total_energy': 0.6523093348834752}, {'distance': 0.5, 'total_energy': -0.15221424567877828}, {'distance': 0.6000000000000001, 'total_energy': -0.3696204820149024}, {'distance': 0.7000000000000002, 'total_energy': -0.332406898702278}, {'distance': 0.8000000000000003, 'total_energy': -0.01777283326791712}, {'distance': 0.9000000000000001, 'total_energy': -0.6504477889180644}, {'distance': 1.0000000000000002, 'total_energy': -0.6749064555385187}, {'distance': 1.1000000000000003, 'total_energy': -0.5373663960487435}, {'distance': 1.2000000000000004, 'total_energy': -0.4838894320094677}, {'distance': 1.3000000000000005, 'total_energy': -0.37129239075214654}, {'distance': 1.4000000000000004, 'total_energy': -0.5347745126266443}, {'distance': 1.5000000000000004, 'total_energy': -0.7045961819266955}, {'distance': 1.6000000000000005, 'total_energy': -0.5970474335054745}, {'distance': 1.7000000000000004, 'total_energy': -0.9372049551386505}, {'distance': 1.8000000000000005, 'total_energy': -0.5401361971732401}, {'distance': 1.9000000000000006, 'total_energy': -0.8656837666457478}, {'distance': 2.0000000000000004, 'total_energy': -0.6047764151342778}, {'distance': 2.1000000000000005, 'total_energy': -0.8992813671435065}, {'distance': 2.2000000000000006, 'total_energy': -0.6931338453727127}, {'distance': 2.3000000000000007, 'total_energy': -0.6565975890596085}, {'distance': 2.4000000000000004, 'total_energy': -0.5454937316761659}]}\"]\n" + ] + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "For a visual representation, you can plot the total energy vs the distance", + "id": "2d1e81329d1eb698" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T11:05:51.370329Z", + "start_time": "2024-06-14T11:05:14.008476Z" + } + }, + "cell_type": "code", + "source": [ + "from json import loads\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_output():\n", + " output = !poetry run qi files run {filename}\n", + " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " distances, energies = [[result[key] for result in results] for key in [\"distance\", \"total_energy\"]]\n", + " fig, ax = plt.subplots()\n", + " ax.plot(distances, energies)\n", + " ax.set_xlabel(\"Distance (Angstrom)\")\n", + " ax.set_ylabel(\"Potential energy (a.u.)\")\n", + " return fig, ax\n", + "\n", + "plot_output()" + ], + "id": "2c9176f1873ad3c7", + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 9 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "You can see a decreasing function in energy, the atoms start repelling each other at low distances, but it is noisy and there is no clear minimal distance.\n", + "\n", + "Let's try again with more iterations for the optimizer" + ], + "id": "12532766a5255712" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T11:08:52.481152Z", + "start_time": "2024-06-14T11:07:31.137568Z" + } + }, + "cell_type": "code", + "source": [ + "# optimizer = COBYLA(maxiter=10) # replace in file\n", + "plot_output()" + ], + "id": "3cd4588bbfe09334", + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 10 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "And then some more iterations (this may take some minutes)", + "id": "18bf8f2a8edddf32" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T11:16:36.706336Z", + "start_time": "2024-06-14T11:12:08.276160Z" + } + }, + "cell_type": "code", + "source": [ + "# optimizer = COBYLA(maxiter=100) # replace in file\n", + "plot_output()" + ], + "id": "5be01bb287638732", + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 11 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Other optimizers are available in `qiskit_algorithms.optimizers` (https://qiskit-community.github.io/qiskit-algorithms/apidocs/qiskit_algorithms.optimizers.html). Finding the best one depends on the problem.", + "id": "1b1cc8d9d57d3a6e" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-14T12:32:41.016517Z", + "start_time": "2024-06-14T12:30:30.481949Z" + } + }, + "cell_type": "code", + "source": [ + "# from qiskit_algorithms.optimizers import NELDER_MEAD\n", + "# \n", + "# optimizer = NELDER_MEAD(maxiter=10) # replace in file\n", + "\n", + "plot_output()" + ], + "id": "7c4ec6665a1799d2", + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 18 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "You can print the circuit that is executed. First we add the circuit to the results, in the file, next we print it with the `print_circuit` function. ", + "id": "caa4cf925d934c99" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "from qiskit import transpile\n", + "\n", + "transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's'])\n", + "result_dict[\"circuit\"] = repr(transpiled_circuit.draw()).replace(\"'\", '\"')\n", + "result_dict[\"circuit_depth\"] = transpiled_circuit.depth()\n" + ], + "id": "7edac0283f5608f8" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "f6357e31c4ddbb2e" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-17T12:54:21.888291Z", + "start_time": "2024-06-17T12:53:38.432718Z" + } + }, + "cell_type": "code", + "source": [ + "from json import loads\n", + "\n", + "def print_circuit(index: int = 0):\n", + " output = !poetry run qi files run {filename}\n", + " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " circuits, circuit_depths = [[result[key] for result in results] for key in [\"circuit\", \"circuit_depth\"]]\n", + " print(circuits[index])\n", + " print(f\"circuit_depth={circuit_depths[index]}\")\n", + " \n", + "print_circuit()" + ], + "id": "d605454a9ede6840", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global phase: 3π/2\n", + " ┌─────────┐┌──────────┐┌───┐┌──────────────┐┌───┐┌───┐ ┌───┐ ┌───┐┌───┐»\n", + "q_0: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[0]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", + " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", + "q_1: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", + " ┌──┴───┴──┐┌──────────┐┌───┐┌──────────────┐┌───┐├───┤└┬───┬┘├───┤┌───┐»\n", + "q_2: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[1]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", + " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", + "q_3: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", + " └───┘ └───┘└─────┘└───┘ »\n", + "« ┌───────────────┐┌───┐┌───┐┌─────┐┌───┐ ┌───┐┌────────────────┐»\n", + "«q_0: ┤ Rz(-1.0*t[0]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├┤ Rz(-0.25*t[2]) ├»\n", + "« └───────────────┘└─┬─┘├───┤└┬───┬┘├───┤ ┌───┐└─┬─┘└────────────────┘»\n", + "«q_1: ───────────────────■──┤ H ├─┤ S ├─┤ H ├─────┤ X ├──■────────────────────»\n", + "« ┌───────────────┐┌───┐├───┤┌┴───┴┐├───┤┌───┐└─┬─┘ »\n", + "«q_2: ┤ Rz(-1.0*t[1]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├┤ X ├──■─────────────────────────»\n", + "« └───────────────┘└─┬─┘└───┘└─────┘└───┘└─┬─┘ »\n", + "«q_3: ───────────────────■─────────────────────■──────────────────────────────»\n", + "« »\n", + "« ┌───┐ ┌───┐┌────────────────┐┌───┐»\n", + "«q_0: ┤ X ├─────────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├»\n", + "« └─┬─┘┌───┐┌───┐┌─────┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘»\n", + "«q_1: ──■──┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├──■──────────────────────■──»\n", + "« └─┬─┘├───┤└─────┘└───┘ ┌───┐└─┬─┘ »\n", + "«q_2: ───────■──┤ X ├─────────────────┤ X ├──■──────────────────────────────»\n", + "« └─┬─┘ ┌───┐ ┌───┐┌───┐└─┬─┘ »\n", + "«q_3: ────────────■───┤ H ├─┤ S ├┤ H ├──■───────────────────────────────────»\n", + "« └───┘ └───┘└───┘ »\n", + "« ┌───┐┌────────────────┐┌───┐ »\n", + "«q_0: ───────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├──────────»\n", + "« ┌───┐┌───┐┌───┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐»\n", + "«q_1: ┤ X ├┤ H ├┤ S ├┤ H ├──────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├»\n", + "« └─┬─┘├───┤├───┤├───┤┌───┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", + "«q_2: ──■──┤ X ├┤ H ├┤ S ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├»\n", + "« └─┬─┘└───┘└───┘└───┘└─┬─┘ └─┬─┘»\n", + "«q_3: ───────■───────────────────■──────────────────────────────────────────■──»\n", + "« »\n", + "« ┌───┐┌───────────────┐┌───┐┌───┐┌───┐┌───┐»\n", + "«q_0: ─────────────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├┤ S ├┤ H ├»\n", + "« ┌─────┐ ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤├───┤├───┤»\n", + "«q_1: ┤ Sdg ├─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├»\n", + "« └─────┘ └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤»\n", + "«q_2: ───────────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├»\n", + "« ┌───┐ ┌─────┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", + "«q_3: ─┤ H ├─┤ Sdg ├┤ H ├──■─────────────────────────────────────────■──┤ H ├»\n", + "« └───┘ └─────┘└───┘ └───┘»\n", + "« ┌───┐┌────────────────┐┌───┐ »\n", + "«q_0: ──────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├─────────────────»\n", + "« ┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐┌─────┐»\n", + "«q_1: ─┤ H ├───────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├┤ Sdg ├»\n", + "« ┌┴───┴┐┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘»\n", + "«q_2: ┤ Sdg ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├───────»\n", + "« └┬───┬┘├───┤└─┬─┘ └─┬─┘ ┌───┐ »\n", + "«q_3: ─┤ S ├─┤ H ├──■──────────────────────────────────────────■───┤ H ├─»\n", + "« └───┘ └───┘ └───┘ »\n", + "« ┌───┐┌───────────────┐┌───┐ »\n", + "«q_0: ──────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├────────────────────»\n", + "« ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌───┐┌───┐»\n", + "«q_1: ─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├┤ H ├»\n", + "« └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤├───┤»\n", + "«q_2: ────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├┤ S ├»\n", + "« ┌─────┐┌───┐└─┬─┘ └─┬─┘└───┘└───┘»\n", + "«q_3: ┤ Sdg ├┤ H ├──■─────────────────────────────────────────■────────────»\n", + "« └─────┘└───┘ »\n", + "« ┌───┐┌───────────────┐┌───┐ »\n", + "«q_0: ───────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├───────────────────────────»\n", + "« ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌─────┐┌───┐ »\n", + "«q_1: ──────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ Sdg ├┤ H ├─────»\n", + "« ┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘└───┘ »\n", + "«q_2: ┤ H ├┤ X ├──■───────────────────────────────■──┤ X ├─────────────────»\n", + "« └───┘└─┬─┘ └─┬─┘ ┌───┐ ┌───┐┌───┐»\n", + "«q_3: ───────■─────────────────────────────────────────■───┤ H ├─┤ S ├┤ H ├»\n", + "« └───┘ └───┘└───┘»\n", + "« ┌───┐┌───────────────┐┌───┐┌───┐ \n", + "«q_0: ──────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├──────────\n", + "« ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤┌───┐┌───┐\n", + "«q_1: ─────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├\n", + "« ┌───┐└─┬─┘ └─┬─┘├───┤├───┤\n", + "«q_2: ┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├\n", + "« └─┬─┘ └─┬─┘├───┤\n", + "«q_3: ──■─────────────────────────────────────────■──┤ H ├\n", + "« └───┘\n", + "circuit_depth=92\n" + ] + } + ], + "execution_count": 28 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "We can use a different encoding, e.g. the Jordan-Wigner encoding, instead of the parity encoding.", + "id": "ee8f86ac5c47b80b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-17T12:49:59.010851Z", + "start_time": "2024-06-17T12:49:15.098922Z" + } + }, + "cell_type": "code", + "source": [ + "# from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "# \n", + "# mapper = JordanWignerMapper() # replace in file\n", + "\n", + "print_circuit()" + ], + "id": "5e209f7bd2c9090a", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global phase: 3π/2\n", + " ┌─────────┐┌──────────┐┌───┐┌──────────────┐┌───┐┌───┐ ┌───┐ ┌───┐┌───┐»\n", + "q_0: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[0]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", + " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", + "q_1: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", + " ┌──┴───┴──┐┌──────────┐┌───┐┌──────────────┐┌───┐├───┤└┬───┬┘├───┤┌───┐»\n", + "q_2: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[1]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", + " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", + "q_3: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", + " └───┘ └───┘└─────┘└───┘ »\n", + "« ┌───────────────┐┌───┐┌───┐┌─────┐┌───┐ ┌───┐┌────────────────┐»\n", + "«q_0: ┤ Rz(-1.0*t[0]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├┤ Rz(-0.25*t[2]) ├»\n", + "« └───────────────┘└─┬─┘├───┤└┬───┬┘├───┤ ┌───┐└─┬─┘└────────────────┘»\n", + "«q_1: ───────────────────■──┤ H ├─┤ S ├─┤ H ├─────┤ X ├──■────────────────────»\n", + "« ┌───────────────┐┌───┐├───┤┌┴───┴┐├───┤┌───┐└─┬─┘ »\n", + "«q_2: ┤ Rz(-1.0*t[1]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├┤ X ├──■─────────────────────────»\n", + "« └───────────────┘└─┬─┘└───┘└─────┘└───┘└─┬─┘ »\n", + "«q_3: ───────────────────■─────────────────────■──────────────────────────────»\n", + "« »\n", + "« ┌───┐ ┌───┐┌────────────────┐┌───┐»\n", + "«q_0: ┤ X ├─────────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├»\n", + "« └─┬─┘┌───┐┌───┐┌─────┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘»\n", + "«q_1: ──■──┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├──■──────────────────────■──»\n", + "« └─┬─┘├───┤└─────┘└───┘ ┌───┐└─┬─┘ »\n", + "«q_2: ───────■──┤ X ├─────────────────┤ X ├──■──────────────────────────────»\n", + "« └─┬─┘ ┌───┐ ┌───┐┌───┐└─┬─┘ »\n", + "«q_3: ────────────■───┤ H ├─┤ S ├┤ H ├──■───────────────────────────────────»\n", + "« └───┘ └───┘└───┘ »\n", + "« ┌───┐┌────────────────┐┌───┐ »\n", + "«q_0: ───────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├──────────»\n", + "« ┌───┐┌───┐┌───┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐»\n", + "«q_1: ┤ X ├┤ H ├┤ S ├┤ H ├──────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├»\n", + "« └─┬─┘├───┤├───┤├───┤┌───┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", + "«q_2: ──■──┤ X ├┤ H ├┤ S ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├»\n", + "« └─┬─┘└───┘└───┘└───┘└─┬─┘ └─┬─┘»\n", + "«q_3: ───────■───────────────────■──────────────────────────────────────────■──»\n", + "« »\n", + "« ┌───┐┌───────────────┐┌───┐┌───┐┌───┐┌───┐»\n", + "«q_0: ─────────────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├┤ S ├┤ H ├»\n", + "« ┌─────┐ ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤├───┤├───┤»\n", + "«q_1: ┤ Sdg ├─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├»\n", + "« └─────┘ └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤»\n", + "«q_2: ───────────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├»\n", + "« ┌───┐ ┌─────┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", + "«q_3: ─┤ H ├─┤ Sdg ├┤ H ├──■─────────────────────────────────────────■──┤ H ├»\n", + "« └───┘ └─────┘└───┘ └───┘»\n", + "« ┌───┐┌────────────────┐┌───┐ »\n", + "«q_0: ──────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├─────────────────»\n", + "« ┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐┌─────┐»\n", + "«q_1: ─┤ H ├───────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├┤ Sdg ├»\n", + "« ┌┴───┴┐┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘»\n", + "«q_2: ┤ Sdg ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├───────»\n", + "« └┬───┬┘├───┤└─┬─┘ └─┬─┘ ┌───┐ »\n", + "«q_3: ─┤ S ├─┤ H ├──■──────────────────────────────────────────■───┤ H ├─»\n", + "« └───┘ └───┘ └───┘ »\n", + "« ┌───┐┌───────────────┐┌───┐ »\n", + "«q_0: ──────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├────────────────────»\n", + "« ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌───┐┌───┐»\n", + "«q_1: ─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├┤ H ├»\n", + "« └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤├───┤»\n", + "«q_2: ────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├┤ S ├»\n", + "« ┌─────┐┌───┐└─┬─┘ └─┬─┘└───┘└───┘»\n", + "«q_3: ┤ Sdg ├┤ H ├──■─────────────────────────────────────────■────────────»\n", + "« └─────┘└───┘ »\n", + "« ┌───┐┌───────────────┐┌───┐ »\n", + "«q_0: ───────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├───────────────────────────»\n", + "« ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌─────┐┌───┐ »\n", + "«q_1: ──────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ Sdg ├┤ H ├─────»\n", + "« ┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘└───┘ »\n", + "«q_2: ┤ H ├┤ X ├──■───────────────────────────────■──┤ X ├─────────────────»\n", + "« └───┘└─┬─┘ └─┬─┘ ┌───┐ ┌───┐┌───┐»\n", + "«q_3: ───────■─────────────────────────────────────────■───┤ H ├─┤ S ├┤ H ├»\n", + "« └───┘ └───┘└───┘»\n", + "« ┌───┐┌───────────────┐┌───┐┌───┐ \n", + "«q_0: ──────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├──────────\n", + "« ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤┌───┐┌───┐\n", + "«q_1: ─────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├\n", + "« ┌───┐└─┬─┘ └─┬─┘├───┤├───┤\n", + "«q_2: ┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├\n", + "« └─┬─┘ └─┬─┘├───┤\n", + "«q_3: ──■─────────────────────────────────────────■──┤ H ├\n", + "« └───┘\n" + ] + } + ], + "execution_count": 25 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Instead of the hydrogen molecule, the VQE algorithm can also be used for different optimization problems. For this, we will replace the `qubit_op` (what we will measure), and the `ansatz` (how we will change the state to be measured). We will measure the operator `X + distance * Z` on one qubit. We have two parameters to optimize, which perform a rotation around the y-axis and then around the z-axis.", + "id": "71fece5c28338049" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "# replace in the file\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "qubit_op = SparsePauliOp([\"X\", \"Z\"], coeffs=np.array([1, distance])) # 3-qubit bitstrings could be [\"XXY\", \"ZYX\"]\n", + "nuclear_repulsion_energy = 0\n", + "\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.circuit import Parameter\n", + "\n", + "params = [Parameter(\"t_0\"), Parameter(\"t_1\")]\n", + "ansatz = QuantumCircuit(1) # 1 = number of qubits\n", + "ansatz.ry(params[0], qubit=0)\n", + "ansatz.rz(params[1], qubit=0)\n", + "\n", + "# add to the file\n", + "result_dict[\"optimal_t_0\"] = result.optimal_parameters[params[0]]\n", + "result_dict[\"optimal_t_1\"] = result.optimal_parameters[params[1]]" + ], + "id": "d94d3ecff8fb7e0d" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Next we will plot the optimal parameters and the calculated \"energy\"", + "id": "626ab8b8d9863237" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-17T14:26:16.461835Z", + "start_time": "2024-06-17T14:23:41.458300Z" + } + }, + "cell_type": "code", + "source": [ + "from json import loads\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "def plot_outputs():\n", + " output = !poetry run qi files run {filename}\n", + " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " keys = [\"distance\", \"total_energy\", \"optimal_t_0\", \"optimal_t_1\"]\n", + " distances, energies, optimal_t_0s, optimal_t_1s = [[result[key] for result in results] for key in keys]\n", + " fig, ax = plt.subplots()\n", + " ax.plot(distances, energies, label=\"Total Energy (a.u.)\")\n", + " ax.plot(distances, np.mod(optimal_t_0s, 2*np.pi) - np.pi, label=\"t_0 (rad)\")\n", + " ax.plot(distances, np.mod(optimal_t_1s, 2*np.pi) - np.pi, label=\"t_1 (rad)\")\n", + " ax.set_xlabel(\"Distance (Angstrom)\")\n", + " ax.legend()\n", + " return fig, ax\n", + "\n", + "plot_outputs()" + ], + "id": "6587e1cab0c242a", + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 49 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Does it make sense what you see as optimization results?\n", + "\n", + "Can you make an optimization problem with two qubits? With three parameters? With more Pauli strings?\n", + "\n", + "What else can you think of?" + ], + "id": "6494604f5be12c96" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "99edb42031a2154e" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/hydrogen_qiskit.py b/examples/hydrogen_qiskit.py index 44fc57e7..05e51a45 100644 --- a/examples/hydrogen_qiskit.py +++ b/examples/hydrogen_qiskit.py @@ -1,10 +1,13 @@ -# (H2) Hydrogen molecuole ground state energy determined using VQE with a UCCSD-ansatz function. +# (H2) Hydrogen molecule ground state energy determined using VQE with a UCCSD-ansatz function. # Compared with Hartee-Fock energies and with energies calculated by NumPyMinimumEigensolver # This script is based on the Qiskit Chemistry tutorials -import warnings from dataclasses import dataclass -from typing import Any, Dict, List +from pathlib import Path +from typing import Any +import matplotlib.pyplot as plt +import numpy as np +from qiskit import transpile from qiskit.primitives import BackendEstimator from qiskit_algorithms import NumPyMinimumEigensolverResult, VQEResult from qiskit_algorithms.minimum_eigensolvers import VQE @@ -13,7 +16,9 @@ from qiskit_nature.second_q.drivers import PySCFDriver from qiskit_nature.second_q.mappers import ParityMapper +from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend +from quantuminspire.util.api.local_backend import LocalBackend from quantuminspire.util.api.quantum_interface import QuantumInterface @@ -24,38 +29,78 @@ class _GroundStateEnergyResults: def calculate_H0(backend: QuantumInspireBackend, distance: float = 0.735) -> _GroundStateEnergyResults: - - mapper = ParityMapper(num_particles=(1, 1)) molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" driver = PySCFDriver(molecule) - with warnings.catch_warnings(): - warnings.simplefilter("ignore", category=UserWarning) - es_problem = driver.run() + es_problem = driver.run() fermionic_op = es_problem.hamiltonian.second_q_op() - qubit_op = mapper.map(fermionic_op) n_particles = es_problem.num_particles n_spatial_orbitals = es_problem.num_spatial_orbitals - nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy - initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) - ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) + mapper = ParityMapper(num_particles=(1, 1)) + qubit_op = mapper.map(fermionic_op) - optimizer = COBYLA(maxiter=1) # 10 iterations take two minutes estimator = BackendEstimator(backend=backend) + initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) + ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) + optimizer = COBYLA(maxiter=1) algo = VQE(estimator, ansatz, optimizer) result = algo.compute_minimum_eigenvalue(qubit_op) - print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy}, eigenvalue={result.eigenvalue}") + # print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy:.2f}, eigenvalue={result.eigenvalue:.2f}") return _GroundStateEnergyResults(result, nuclear_repulsion_energy) def execute(qi: QuantumInterface) -> None: - c = calculate_H0(backend=QuantumInspireBackend(qi)) - print(c) + # distances = np.arange(0.3, 2.5, 0.1) + distances = np.arange(0.3, 0.5, 0.1) + results = [] + for distance in distances: + ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) + # result = dataclasses.asdict(ground_state_energy_results) + result = {} + # result["eigenvalue"] = ground_state_energy_results.result.eigenvalue + # result["nuclear_repulsion_energy"] = ground_state_energy_results.nuclear_repulsion_energy + result["total_energy"] = ground_state_energy_results.nuclear_repulsion_energy + ground_state_energy_results.result.eigenvalue + result["distance"] = distance + results.append(result) + # print(f"{distance}, {result['total_energy']}") + + qi.results = {"results": results} + # print(results) + + +def finalize(results: Any) -> dict[str, Any]: + return results + + +if __name__ == "__main__": + # Run the individual steps for debugging + algorithm = HybridAlgorithm("test", "test") + algorithm.read_file(Path(__file__)) + + # from quantuminspire.util.api.remote_backend import RemoteBackend + # backend = RemoteBackend() + # job_id = backend.run(algorithm, backend_type_id=3, number_of_shots=1024) + # results = backend.get_results(job_id) + + local_backend = LocalBackend() + job_id = local_backend.run(algorithm, 0) + results = local_backend.get_results(job_id)["results"] + print("=== Execute ===\n", results) + + # plot total energy vs distance between atoms + for y_name in ["total_energy"]: + distances, energies = [[result[key] for result in results] for key in ["distance", y_name]] + plt.plot(distances, energies, label=y_name) + plt.legend() + plt.show() + plt.savefig(Path("~/repositories/quantuminspire2/env/test.png").expanduser()) + + # draw optimal circuit of first distance as text + circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) + print(circuit.draw("text")) -def finalize(list_of_measurements: Dict[int, List[Any]]) -> Dict[str, Any]: - return {"measurements": list_of_measurements} diff --git a/examples/simple_vqe.py b/examples/simple_vqe.py new file mode 100644 index 00000000..a6b9e4ed --- /dev/null +++ b/examples/simple_vqe.py @@ -0,0 +1,121 @@ +# (H2) Hydrogen molecule ground state energy determined using VQE with a UCCSD-ansatz function. +# Compared with Hartee-Fock energies and with energies calculated by NumPyMinimumEigensolver +# This script is based on the Qiskit Chemistry tutorials +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import matplotlib.pyplot as plt +import numpy as np +from qiskit import transpile +from qiskit.primitives import BackendEstimator +from qiskit_algorithms import NumPyMinimumEigensolverResult, VQEResult +from qiskit_algorithms.minimum_eigensolvers import VQE +from qiskit_algorithms.optimizers import COBYLA +from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock +from qiskit_nature.second_q.drivers import PySCFDriver +from qiskit_nature.second_q.mappers import ParityMapper + +from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm +from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend +from quantuminspire.util.api.local_backend import LocalBackend +from quantuminspire.util.api.quantum_interface import QuantumInterface + + +@dataclass +class _GroundStateEnergyResults: + result: VQEResult | NumPyMinimumEigensolverResult + nuclear_repulsion_energy: float + + +def calculate_H0(backend: QuantumInspireBackend, distance: float = 0.735) -> _GroundStateEnergyResults: + molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" + driver = PySCFDriver(molecule) + es_problem = driver.run() + + fermionic_op = es_problem.hamiltonian.second_q_op() + n_particles = es_problem.num_particles + n_spatial_orbitals = es_problem.num_spatial_orbitals + nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy + + mapper = ParityMapper(num_particles=(1, 1)) + qubit_op = mapper.map(fermionic_op) + + from qiskit.quantum_info import Pauli + qubit_op = Pauli("X") + + estimator = BackendEstimator(backend=backend) + initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) + ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) + + from qiskit import QuantumCircuit + from qiskit.circuit import Parameter + params = [Parameter("t_0"), Parameter("t_1")] + + ansatz = QuantumCircuit(1) + ansatz.ry(params[0], qubit=0) + ansatz.rz(params[1], qubit=0) + + optimizer = COBYLA(maxiter=1) + + algo = VQE(estimator, ansatz, optimizer) + result = algo.compute_minimum_eigenvalue(qubit_op) + + breakpoint() + result.optimal_parameters + + # print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy:.2f}, eigenvalue={result.eigenvalue:.2f}") + return _GroundStateEnergyResults(result, nuclear_repulsion_energy) + + +def execute(qi: QuantumInterface) -> None: + # distances = np.arange(0.3, 2.5, 0.1) + distances = np.arange(0.3, 0.5, 0.1) + results = [] + for distance in distances: + ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) + # result = dataclasses.asdict(ground_state_energy_results) + result = {} + # result["eigenvalue"] = ground_state_energy_results.result.eigenvalue + # result["nuclear_repulsion_energy"] = ground_state_energy_results.nuclear_repulsion_energy + result["total_energy"] = ground_state_energy_results.nuclear_repulsion_energy + ground_state_energy_results.result.eigenvalue + result["distance"] = distance + results.append(result) + # print(f"{distance}, {result['total_energy']}") + + qi.results = {"results": results} + # print(results) + + +def finalize(results: Any) -> dict[str, Any]: + return results + + +if __name__ == "__main__": + # Run the individual steps for debugging + algorithm = HybridAlgorithm("test", "test") + algorithm.read_file(Path(__file__)) + + # from quantuminspire.util.api.remote_backend import RemoteBackend + # backend = RemoteBackend() + # job_id = backend.run(algorithm, backend_type_id=3, number_of_shots=1024) + # results = backend.get_results(job_id) + + local_backend = LocalBackend() + job_id = local_backend.run(algorithm, 0) + results = local_backend.get_results(job_id)["results"] + print("=== Execute ===\n", results) + + # plot total energy vs distance between atoms + for y_name in ["total_energy"]: + distances, energies = [[result[key] for result in results] for key in ["distance", y_name]] + plt.plot(distances, energies, label=y_name) + plt.legend() + plt.show() + plt.savefig(Path("~/repositories/quantuminspire2/env/test.png").expanduser()) + + # draw optimal circuit of first distance as text + circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) + print(circuit.draw("text")) + + diff --git a/quantuminspire/util/api/local_backend.py b/quantuminspire/util/api/local_backend.py index 7eaf4b96..a8715990 100644 --- a/quantuminspire/util/api/local_backend.py +++ b/quantuminspire/util/api/local_backend.py @@ -94,8 +94,12 @@ def run_hybrid(self, algorithm: HybridAlgorithm, quantum_interface: QuantumInter def run_quantum(self, circuit: str, number_of_shots: int = 1) -> ExecuteCircuitResult: """Execute provided circuit.""" result = self._qxelarator.execute_string(circuit, iterations=number_of_shots) + # Qiskit requires the keys to be in hex notation + # todo: use result.results instead of result.state. qxelerator has a bug where it returns only "00" for + # result.results, but result.state contains the correct probability for all multi-qubit states. + results = {hex(int(key, 2)): int(round(number_of_shots * abs(val) ** 2)) for key, val in result.state.items()} return ExecuteCircuitResult( - results=result.results, + results=results, shots_done=result.shots_done, shots_requested=result.shots_requested, ) From 46313d5f9ce25aba871acd57092edb3f9319e834 Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Tue, 18 Jun 2024 14:12:49 +0200 Subject: [PATCH 2/9] cleaned up hydrogen algorithm py file and jupyter notebook --- examples/hydrogen_algorithm.py | 78 ----- examples/hydrogen_qiskit.ipynb | 590 +++++++-------------------------- examples/hydrogen_qiskit.py | 21 +- examples/simple_vqe.py | 121 ------- 4 files changed, 134 insertions(+), 676 deletions(-) delete mode 100644 examples/hydrogen_algorithm.py delete mode 100644 examples/simple_vqe.py diff --git a/examples/hydrogen_algorithm.py b/examples/hydrogen_algorithm.py deleted file mode 100644 index 713a284b..00000000 --- a/examples/hydrogen_algorithm.py +++ /dev/null @@ -1,78 +0,0 @@ -from typing import Any -from quantuminspire.util.api.quantum_interface import QuantumInterface -import numpy as np - - -def execute(qi: QuantumInterface) -> None: - distances = np.arange(0.3, 2.5, 0.1) - results = [] - for distance in distances: - from qiskit_nature.second_q.drivers import PySCFDriver - - - molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" - driver = PySCFDriver(molecule) - es_problem = driver.run() - - fermionic_op = es_problem.hamiltonian.second_q_op() - n_particles = es_problem.num_particles - n_spatial_orbitals = es_problem.num_spatial_orbitals - nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy - - from qiskit_nature.second_q.mappers import ParityMapper - from qiskit_nature.second_q.mappers import JordanWignerMapper - - mapper = JordanWignerMapper() - qubit_op = mapper.map(fermionic_op) - - from qiskit.quantum_info import SparsePauliOp - - qubit_op = SparsePauliOp(["X", "Z"], coeffs=np.array([1, distance])) - nuclear_repulsion_energy = 0 - - from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD - - initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) - ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) - - from qiskit import QuantumCircuit - from qiskit.circuit import Parameter - params = [Parameter("t_0"), Parameter("t_1")] - - ansatz = QuantumCircuit(1) - ansatz.ry(params[0], qubit=0) - ansatz.rz(params[1], qubit=0) - - from qiskit.primitives import BackendEstimator - from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend - - backend = QuantumInspireBackend(qi) # qi is passed into `execute` - estimator = BackendEstimator(backend=backend) - - from qiskit_algorithms.optimizers import COBYLA - - optimizer = COBYLA(maxiter=100) - - from qiskit_algorithms import VQE - - algo = VQE(estimator, ansatz, optimizer) - result = algo.compute_minimum_eigenvalue(qubit_op) - - result_dict = {"distance": distance, "total_energy": result.eigenvalue + nuclear_repulsion_energy} - - from qiskit import transpile - - transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) - result_dict["circuit"] = repr(transpiled_circuit.draw()).replace("'", '"') - result_dict["circuit_depth"] = transpiled_circuit.depth() - result_dict["optimal_t_0"] = result.optimal_parameters[params[0]] - result_dict["optimal_t_1"] = result.optimal_parameters[params[1]] - - # result_dict["circuit"] = result.optimal_circuit.decompose(reps=20).draw("text") - results.append(result_dict) - - qi.results = {"results": results} - - -def finalize(results: Any) -> dict[str, Any]: - return results diff --git a/examples/hydrogen_qiskit.ipynb b/examples/hydrogen_qiskit.ipynb index d2288faf..026e143a 100644 --- a/examples/hydrogen_qiskit.ipynb +++ b/examples/hydrogen_qiskit.ipynb @@ -9,18 +9,28 @@ { "metadata": {}, "cell_type": "markdown", - "source": "Make a new empty Python file", + "source": [ + "This notebook describes running a hybrid quantum classical algorith to calculate the electronic ground state energy of a hydrogen molecule on the Quantum Inspire platform.\n", + "\n", + "Part of the cells in the notebook are to be executed. Another part are to be copied to another file." + ], + "id": "e7de03d20a964a8" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Setting up the algorithm Python file\n", + "\n", + "We start by make a new empty Python file to hold the algorithm." + ], "id": "66d29b62f486f266" }, { "cell_type": "code", "id": "initial_id", "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2024-06-17T12:13:09.413470Z", - "start_time": "2024-06-17T12:13:09.204526Z" - } + "collapsed": true }, "source": [ "from pathlib import Path\n", @@ -28,28 +38,18 @@ "filename = str(Path.cwd() / \"hydrogen_algorithm.py\") \n", "!touch {filename}" ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n" - ] - } - ], - "execution_count": 2 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Add an `execute` and a `finalize` function to the file with the following input arguments", + "source": "Add an `execute` and a `finalize` function to the file with the following input arguments:", "id": "9e06c3bfbc525b76" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from typing import Any\n", "from quantuminspire.util.api.quantum_interface import QuantumInterface\n", @@ -61,19 +61,19 @@ "def finalize(results: Any) -> dict[str, Any]:\n", " ..." ], - "id": "8daaf3f52f28f96e" + "id": "8daaf3f52f28f96e", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Have the `execute` function add something to the results, and have `finalize` return them", + "source": "Have the `execute` function add something to the results, and have `finalize` return them:", "id": "6614ddb463e43d1c" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from typing import Any\n", "from quantuminspire.util.api.quantum_interface import QuantumInterface\n", @@ -85,21 +85,18 @@ "def finalize(results: Any) -> dict[str, Any]:\n", " return results" ], - "id": "5999967ad19c277d" + "id": "5999967ad19c277d", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Use the `print_output` function to execute the Python file and print its output", + "source": "Use the `print_output` function to execute the Python file and print its output:", "id": "bc44c6b00b985cd7" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-17T13:38:07.452718Z", - "start_time": "2024-06-17T13:37:48.117337Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "def print_output():\n", @@ -109,21 +106,15 @@ "print_output()" ], "id": "4031bb12fe6b4615", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.3, 'total_energy': 1.4865802864000002, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.450434622822838, 'optimal_t_1': 4.4214434387828305}, {'distance': 0.4, 'total_energy': 1.3952086523, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 6.192765932878906, 'optimal_t_1': -3.7698206453031022}, {'distance': 0.5, 'total_energy': 0.9939012968400001, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 0.06484530325044346, 'optimal_t_1': -3.1347833911582352}, {'distance': 0.6000000000000001, 'total_energy': 0.8643838932, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.308178940539449, 'optimal_t_1': 1.5947722559472224}, {'distance': 0.7000000000000002, 'total_energy': 0.32432681917142847, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 5.4133968705340045, 'optimal_t_1': 5.3111698206458655}, {'distance': 0.8000000000000003, 'total_energy': 0.5950652636499999, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.487358235890828, 'optimal_t_1': 1.6631224966426652}, {'distance': 0.9000000000000001, 'total_energy': 0.3614121788, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.952151286508921, 'optimal_t_1': -2.3425545376628776}, {'distance': 1.0000000000000002, 'total_energy': 0.4315209609199999, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -0.12433859380029322, 'optimal_t_1': 0.653287389810159}, {'distance': 1.1000000000000003, 'total_energy': 1.4127108167454545, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.783008108547035, 'optimal_t_1': 3.4516296666984925}, {'distance': 1.2000000000000004, 'total_energy': -0.3012064909000001, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.404402559250089, 'optimal_t_1': 3.407777863206878}, {'distance': 1.3000000000000005, 'total_energy': 0.44416876801538446, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.2206591336320312, 'optimal_t_1': 1.6101765814433087}, {'distance': 1.4000000000000004, 'total_energy': 0.10649934708571424, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.086286912278961, 'optimal_t_1': 4.370952198454573}, {'distance': 1.5000000000000004, 'total_energy': 0.82153480728, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.112973326613269, 'optimal_t_1': 2.1207005943201516}, {'distance': 1.6000000000000005, 'total_energy': 0.889329506825, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -4.020389080010611, 'optimal_t_1': -0.7604473956951798}, {'distance': 1.7000000000000004, 'total_energy': 0.7937025873058823, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -0.8223768024227915, 'optimal_t_1': 3.9938180460292543}, {'distance': 1.8000000000000005, 'total_energy': 0.22562796439999994, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.907014752663402, 'optimal_t_1': -4.411875898738632}, {'distance': 1.9000000000000006, 'total_energy': 0.637889321536842, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 1.0008465262372193, 'optimal_t_1': 1.1289165130082024}, {'distance': 2.0000000000000004, 'total_energy': -0.52642701954, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 2.2258030179644592, 'optimal_t_1': -3.076163042503146}, {'distance': 2.1000000000000005, 'total_energy': 0.6094110230571428, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -2.77542510895853, 'optimal_t_1': 3.2184027576366745}, {'distance': 2.2000000000000006, 'total_energy': -0.4352461541272728, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -1.6104117584643305, 'optimal_t_1': 0.8275302919839298}, {'distance': 2.3000000000000007, 'total_energy': -0.1781260767739131, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': -5.203329156373638, 'optimal_t_1': -4.230668923664325}, {'distance': 2.4000000000000004, 'total_energy': 0.99392800455, 'circuit': ' ┌─────────┐┌─────────┐\\\\nq: ┤ Ry(t_0) ├┤ Rz(t_1) ├\\\\n └─────────┘└─────────┘', 'circuit_depth': 2, 'optimal_t_0': 4.026376152689799, 'optimal_t_1': -3.104746427529323}]}\"]\n" - ] - } - ], - "execution_count": 35 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", "source": [ + "### Adding the hydrogen algorithm\n", + "\n", "In the next couple of cells, we will be adding the hydrogen algorithm to the `execute` function. Add these commands to the function.\n", "\n", "Specify a molecule configuration with the distance between the atoms. Make a molecule driver from this, and use it to generate an ElectronicStructureProblem." @@ -133,8 +124,6 @@ { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit_nature.second_q.drivers import PySCFDriver\n", "\n", @@ -143,7 +132,9 @@ "driver = PySCFDriver(molecule)\n", "es_problem = driver.run()" ], - "id": "b38435ca858dbfdc" + "id": "b38435ca858dbfdc", + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -154,65 +145,63 @@ { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "fermionic_op = es_problem.hamiltonian.second_q_op()\n", "n_particles = es_problem.num_particles\n", "n_spatial_orbitals = es_problem.num_spatial_orbitals\n", "nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy" ], - "id": "477e8407a0431666" + "id": "477e8407a0431666", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Map the fermionic operators onto qubit operators", + "source": "Map the fermionic (electronic) operators for the Hamiltonian onto qubit operators:", "id": "6c7e16c0f2820b49" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit_nature.second_q.mappers import ParityMapper\n", "\n", "mapper = ParityMapper(num_particles=(1, 1))\n", "qubit_op = mapper.map(fermionic_op)" ], - "id": "fc33cb8697944cfc" + "id": "fc33cb8697944cfc", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Make the ansatz from the initial state", + "source": "Make the ansatz from the initial state, using the same mapper:", "id": "a1bf4fee6fd38098" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD\n", "\n", "initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper)\n", "ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state)" ], - "id": "1d3a53b494fc14f4" + "id": "1d3a53b494fc14f4", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Use Quantum Inspire's Qiskit backend to make the estimator", + "source": "Use Quantum Inspire's Qiskit backend to make the estimator:", "id": "7b158797c551827a" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit.primitives import BackendEstimator\n", "from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend\n", @@ -220,44 +209,46 @@ "backend = QuantumInspireBackend(qi) # qi is passed into `execute`\n", "estimator = BackendEstimator(backend=backend)" ], - "id": "1fb2c8afaac72b5d" + "id": "1fb2c8afaac72b5d", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Make the optimizer", + "source": "Make the optimizer:", "id": "4239c37767049c0b" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit_algorithms.optimizers import COBYLA\n", "\n", "optimizer = COBYLA(maxiter=1)" ], - "id": "728112b2b33aa466" + "id": "728112b2b33aa466", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Put everything together to make the VQE algorithm, and run it to get the result", + "source": "Put everything together to make the VQE algorithm, and run it to get the result:", "id": "31c9e48ce16f2142" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit_algorithms import VQE\n", "\n", "algo = VQE(estimator, ansatz, optimizer)\n", "result = algo.compute_minimum_eigenvalue(qubit_op)" ], - "id": "21c37beed3723f1c" + "id": "21c37beed3723f1c", + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -268,10 +259,10 @@ { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": "qi.results = {\"results\": [{\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}]}", - "id": "1748e8c980182c56" + "id": "1748e8c980182c56", + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -280,30 +271,19 @@ "id": "4cbcdab535882a1c" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T10:43:21.922122Z", - "start_time": "2024-06-14T10:43:14.426455Z" - } - }, + "metadata": {}, "cell_type": "code", "source": "print_output()", "id": "dcee350bc09a7064", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.735, 'total_energy': -0.3868728641492053}]}\"]\n" - ] - } - ], - "execution_count": 5 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", "source": [ + "### Varying the distance between the atoms\n", + "\n", "Now that we can calculate the total energy for a single distance, let's vary the distance and see what happens.\n", "\n", "Wrap the entire body of the execute function in a for loop to loop over different distances, replacing the constant `distance`." @@ -313,8 +293,6 @@ { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "import numpy as np\n", "\n", @@ -328,48 +306,32 @@ " \n", " qi.results = {\"results\": results}" ], - "id": "fb84e1461cd3efcb" + "id": "fb84e1461cd3efcb", + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Print the output to see the total energy for different distances", + "source": "Print the output to see the total energy for different distances:", "id": "3be6069522c094ba" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T10:57:33.948418Z", - "start_time": "2024-06-14T10:57:07.773340Z" - } - }, + "metadata": {}, "cell_type": "code", "source": "print_output()", "id": "378ee61864fa2526", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', \"/home/haroldmeerwaldt/.cache/pypoetry/virtualenvs/quantuminspire-3d1CX1g5-py3.10/lib/python3.10/site-packages/numpy/core/getlimits.py:542: UserWarning: Signature b'\\\\x00\\\\xd0\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xcc\\\\xfb\\\\xbf\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00' for does not match any known type: falling back to type probe function.\", 'This warnings indicates broken support for the dtype!', ' machar = _get_machar(dtype)', \"{'results': [{'distance': 0.3, 'total_energy': 0.6049237873477202}, {'distance': 0.4, 'total_energy': 0.6523093348834752}, {'distance': 0.5, 'total_energy': -0.15221424567877828}, {'distance': 0.6000000000000001, 'total_energy': -0.3696204820149024}, {'distance': 0.7000000000000002, 'total_energy': -0.332406898702278}, {'distance': 0.8000000000000003, 'total_energy': -0.01777283326791712}, {'distance': 0.9000000000000001, 'total_energy': -0.6504477889180644}, {'distance': 1.0000000000000002, 'total_energy': -0.6749064555385187}, {'distance': 1.1000000000000003, 'total_energy': -0.5373663960487435}, {'distance': 1.2000000000000004, 'total_energy': -0.4838894320094677}, {'distance': 1.3000000000000005, 'total_energy': -0.37129239075214654}, {'distance': 1.4000000000000004, 'total_energy': -0.5347745126266443}, {'distance': 1.5000000000000004, 'total_energy': -0.7045961819266955}, {'distance': 1.6000000000000005, 'total_energy': -0.5970474335054745}, {'distance': 1.7000000000000004, 'total_energy': -0.9372049551386505}, {'distance': 1.8000000000000005, 'total_energy': -0.5401361971732401}, {'distance': 1.9000000000000006, 'total_energy': -0.8656837666457478}, {'distance': 2.0000000000000004, 'total_energy': -0.6047764151342778}, {'distance': 2.1000000000000005, 'total_energy': -0.8992813671435065}, {'distance': 2.2000000000000006, 'total_energy': -0.6931338453727127}, {'distance': 2.3000000000000007, 'total_energy': -0.6565975890596085}, {'distance': 2.4000000000000004, 'total_energy': -0.5454937316761659}]}\"]\n" - ] - } - ], - "execution_count": 6 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "For a visual representation, you can plot the total energy vs the distance", + "source": "For a visual representation, you can plot the total energy vs the distance:", "id": "2d1e81329d1eb698" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T11:05:51.370329Z", - "start_time": "2024-06-14T11:05:14.008476Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "from json import loads\n", @@ -388,78 +350,36 @@ "plot_output()" ], "id": "2c9176f1873ad3c7", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAAGyCAYAAAAWFJs3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABqwUlEQVR4nO3dd1hTZ/sH8O8JI+wgshEBRXHvhbVOFEet2mWHVTtta2tb9e2r/Vl9O61ttXarHVprW1u3VevCrahVwAkoQ0GmiIS9kvP7AxKlsgJJTgLfz3XlupqTc3JuTDG39/M89yOIoiiCiIiIiGokkzoAIiIiIlPHhImIiIioDkyYiIiIiOrAhImIiIioDkyYiIiIiOrAhImIiIioDkyYiIiIiOrAhImIiIioDkyYiIiIiOpgKXUApk6tViM1NRWOjo4QBEHqcIiIiKgeRFFEXl4evL29IZPpoT4kmomPPvpI7NOnj+jg4CC6ubmJEyZMEGNiYuq87s8//xSDgoJEuVwudunSRdy5c6dO901OThYB8MEHH3zwwQcfZvhITk5uaOpRhdlUmA4fPoyZM2eib9++KC8vx9tvv41Ro0bh8uXLsLe3r/aaEydO4IknnsDixYvxwAMP4LfffsPEiRMRERGBLl261Ou+jo6OAIDk5GQ4OTnp7echIiIiw8nNzYWvr6/2e7yxBFE0z813b968CXd3dxw+fBiDBw+u9pzJkyejoKAAO3bs0B4bMGAAevTogRUrVtTrPrm5uVAoFFAqlUyYiIiIzIS+v7/NdtK3UqkEALi4uNR4Tnh4OEJCQqocCw0NRXh4eI3XlJSUIDc3t8qDiIiImjezTJjUajXeeOMN3HfffbUOraWnp8PDw6PKMQ8PD6Snp9d4zeLFi6FQKLQPX19fvcVNRERE5sksE6aZM2fi4sWLWL9+vd7fe/78+VAqldpHcnKy3u9BRERE5sVsJn1rvPrqq9ixYweOHDmCVq1a1Xqup6cnMjIyqhzLyMiAp6dnjdfI5XLI5XK9xEpERERNg9lUmERRxKuvvootW7bgwIEDCAgIqPOa4OBghIWFVTm2b98+BAcHGypMIiIiaoLMpsI0c+ZM/Pbbb9i2bRscHR2185AUCgVsbW0BAFOnToWPjw8WL14MAHj99dcxZMgQLF26FOPGjcP69etx5swZrFq1SrKfg4iIiMyP2VSYvvvuOyiVSgwdOhReXl7axx9//KE9JykpCWlpadrnAwcOxG+//YZVq1ahe/fu2LhxI7Zu3VrvHkxEREREgBn3YTIW9mEiIiIyP+zDRERERGRkTJiIiIiI6sCEiYiIiKgOTJiIiIiI6sCESSIl5Spcv1WAW/klUodCREREdWDCJJG5G85jyKeHsDkiRepQiIiIqA5MmCTirbABAKQqiySOhIiIiOrChEkiXpUJU1pOscSREBERUV2YMEnEy7liO5c0VpiIiIhMHhMmiXgrKhKmVCUrTERERKaOCZNEvJwrhuSy8ktQWq6WOBoiIiKqDRMmibS0t4a1pQyiCGTksspERERkypgwSUQQhDsTvzksR0REZNKYMEnI00mTMHHiNxERkSljwiQh78qVcqlsLUBERGTSmDBJ6M6QHCtMREREpowJk4S8WGEiIiIyC0yYJOTNChMREZFZYMIkIa/K5pXpXCVHRERk0pgwSci7snnlrYJSFJepJI6GiIiIasKESUIKWyvYWlkAYJWJiIjIlDFhktDdzStTOY+JiIjIZDFhkphmT7k0rpQjIiIyWUyYJKaZ+M2VckRERKaLCZPEvLVDcqwwERERmSomTBLTNK9My2GFiYiIyFQxYZLYne1RWGEiIiIyVUyYJKbZgJcJExERkeliwiQxTYVJWVSGwtJyiaMhIiKi6jBhkpijjRUc5JYAuAkvERGRqWLCZAK8uAkvERGRSWPCZALurJRjhYmIiMgUMWEyAd7cHoWIiMikMWEyAdpu36wwERERmSQmTCZAu59cLhMmIiIiU8SEyQR4K9jtm4iIyJQxYTIB2goTm1cSERGZJCZMJkDTViC/pBy5xWUSR0NERET/xoTJBNhZW0JhawWAE7+JiIhMERMmE+HF1gJEREQmiwmTifBm80oiIiKTxYTJRHB7FCIiItPFhMlEaCtMXClHRERkcpgwmQhWmIiIiEwXEyYTwe1RiIiITBcTJhNx9yo5URQljoaIiIjuxoTJRHhWJkzFZWrkFLJ5JRERkSlhwmQibKws0NLeGgB7MREREZkaJkwmRLunHOcxERERmRSzSpiOHDmC8ePHw9vbG4IgYOvWrbWef+jQIQiCcM8jPT3dOAHrSDvxmxUmIiIik2JWCVNBQQG6d++Ob775RqfrYmNjkZaWpn24u7sbKMLG8da2FmCFiYiIyJRYSh2ALsaMGYMxY8bofJ27uzucnZ31H5CeebF5JRERkUkyqwpTQ/Xo0QNeXl4YOXIkjh8/Xuu5JSUlyM3NrfIwFm1rgRwOyREREZmSJp0weXl5YcWKFdi0aRM2bdoEX19fDB06FBERETVes3jxYigUCu3D19fXePEqWGEiIiIyRYJopl0SBUHAli1bMHHiRJ2uGzJkCFq3bo1ffvml2tdLSkpQUlKifZ6bmwtfX18olUo4OTk1JuQ6JWcX4v5PDsLaQoaY90dDJhMMej8iIqKmKjc3FwqFQm/f32Y1h0kf+vXrh2PHjtX4ulwuh1wuN2JEd3gqbCAIQKlKjVsFpXBzlCYOIiIiqqpJD8lVJyoqCl5eXlKHUS0rCxncHCqSJLYWICIiMh1mVWHKz89HXFyc9nliYiKioqLg4uKC1q1bY/78+UhJScHatWsBAMuXL0dAQAA6d+6M4uJi/PDDDzhw4AD27t0r1Y9QJy9nW2TmlSA1pxjdWkkdDREREQFmljCdOXMGw4YN0z6fPXs2AGDatGlYs2YN0tLSkJSUpH29tLQUc+bMQUpKCuzs7NCtWzfs37+/ynuYGm+FDc4lA+msMBEREZkMs530bSz6njRWl/f+uoyfjidixuA2mD+2o8HvR0RE1BTp+/u72c1hMnXelfvJpbK1ABERkclgwmRiPDXbo7B5JRERkclgwmRi2LySiIjI9DBhMjGaIbn03GKo1JxeRkREZAqYMJkYd0cbWMgEqNQibuaV1H0BERERGRwTJhNjIRPgUdnhO5WtBYiIiEwCEyYT5OVcMY8pnfOYiIiITAITJhPkVblSLpUr5YiIiEwCEyYT5O3MlXJERESmhAmTCfJ0quzFxDlMREREJoEJkwnSdvvOYYWJiIjIFDBhMkF3mleywkRERGQKmDCZIK/KClNmXgnKVGqJoyEiIiImTCbI1V4OKwsBoghk5HJYjoiISGpMmEyQTCZoN+FlLyYiIiLpMWEyUZp5TKlMmIiIiCTHhMlEeVdWmNLYvJKIiEhyTJhMlKeCzSuJiIhMBRMmE3WnFxMrTERERFJjwmSivFhhIiIiMhlMmEyUZgNeNq8kIiKSHhMmE6XZgDcrvxQl5SqJoyEiImremDCZqBZ2VpBbVnw8GcoSiaMhIiJq3pgwmShBELRVplQOyxEREUmKCZMJ4zwmIiIi08CEyYRptkdJzeFKOSIiIikxYTJh3trWAqwwERERSYkJkwnzctZsj8IKExERkZSYMJkwb27AS0REZBKYMJkwTYUpnUNyREREkmLCZMI026PcLixDUSmbVxIREUmFCZMJc7KxhL21BQBO/CYiIpISEyYTJggCvJy5CS8REZHUmDCZOC9tLyZWmIiIiKTChMnE3en2zQoTERGRVJgwmTgvNq8kIiKSHBMmE+ftzO1RiIiIpMaEycRpKkzpHJIjIiKSDBMmE6etMHFIjoiISDKWupwcHR2N9evX4+jRo7h+/ToKCwvh5uaGnj17IjQ0FA8//DDkcrmhYm2WNBWmvOJy5JeUw0Gu00dGREREelCvClNERARCQkLQs2dPHDt2DP3798cbb7yB999/H1OmTIEoivi///s/eHt7Y8mSJSgpKTF03M2GvdwSTjYVSVIaWwsQERFJol7liocffhj/+c9/sHHjRjg7O9d4Xnh4OL744gssXboUb7/9tr5ibPa8FLbILc5DqrIY7TwcpQ6HiIio2alXwnTlyhVYWVnVeV5wcDCCg4NRVlbW6MDoDi9nG8Rm5LHCREREJJF6DcnVJ1lqzPlUO808plSulCMiIpKE3lbJnTlzBkeOHNHX29FdvDXdvllhIiIikoTellw9/fTTuHLlClQqlb7ekippNuBNz2WFiYiISAp6S5jCwsI4d8lAvLkBLxERkaT0ljB5e3vr663oXzQVpjRlMURRhCAIEkdERETUvOg8hykpKanWhyEdOXIE48ePh7e3NwRBwNatW+u85tChQ+jVqxfkcjkCAwOxZs0ag8ZoCF6VFabCUhVyi8oljoaIiKj50bnC5O/vX2uFw5BzmAoKCtC9e3c8++yzeOihh+o8PzExEePGjcNLL72EX3/9FWFhYXj++efh5eWF0NBQg8WpbzZWFmhhZ4XbhWVIVRZBYcdViERERMakc8IUGRlZ5XlZWRkiIyOxbNkyfPjhh3oLrDpjxozBmDFj6n3+ihUrEBAQgKVLlwIAOnbsiGPHjuHzzz83q4QJqGgtcLuwDGnKInT0cpI6HCIiomZF54Spe/fu9xzr06cPvL298emnn9ar8mMs4eHhCAkJqXIsNDQUb7zxRo3XlJSUVNnaJTc311Dh6cTb2QaX03KRmsOVckRERMamtz5MQUFB+Oeff/T1dnqRnp4ODw+PKsc8PDyQm5uLoqLqV5wtXrwYCoVC+/D19TVGqHXSNK9MU3KlHBERkbHpnDDl5uZWeSiVSsTExGDBggVo166dIWI0qvnz50OpVGofycnJUocEoGJ7FKBipRwREREZl85Dcs7OzvdM+hZFEb6+vli/fr3eAtMHT09PZGRkVDmWkZEBJycn2NraVnuNXC6HXC43Rng68dZUmDgkR0REZHQ6J0wHDx6s8lwmk8HNzQ2BgYGwtNRbWye9CA4Oxq5du6oc27dvH4KDgyWKqOE0rQU4JEdERGR8Omc4Q4YMMUQc9ZKfn4+4uDjt88TERERFRcHFxQWtW7fG/PnzkZKSgrVr1wIAXnrpJXz99dd466238Oyzz+LAgQP4888/sXPnTql+hAbzZvNKIiIiyeht0ndaWprBG1eeOXMGPXv2RM+ePQEAs2fPRs+ePbFw4cJqYwgICMDOnTuxb98+dO/eHUuXLsUPP/xgdi0FAMDdqWKYsKRcjeyCUomjISIial4EURRFfbxRx44dm+Tmu7m5uVAoFFAqlXBykrb/UZ8P9iMrvwQ7XhuELj4KSWMhIiIyZfr+/tbbpKO1a9eisLBQX29H1fB2tkFWfglSc4qYMBERERmR3hKmvn376uutqAZeChucv6FkawEiIiIj09scJjK8O80rmTAREREZk84VJpVKhc8//xx//vknkpKSUFpadQJydna23oKjqryd2VqAiIhICjpXmN59910sW7YMkydPhlKpxOzZs/HQQw9BJpPhf//7nwFCJA0vNq8kIiKShM4J06+//orvv/8ec+bMgaWlJZ544gn88MMPWLhwIU6ePGmIGKmSpsKUygoTERGRUemcMKWnp6Nr164AAAcHByiVSgDAAw88YJYNIc2JZ2WFKSO3GGq1XrpBEBERUT3onDC1atUKaWlpAIC2bdti7969AIB//vnHJPdga0o8HOWQCUCZSkRWfonU4RARETUbOidMkyZNQlhYGADgtddewzvvvIN27dph6tSpePbZZ/UeIN1haSGDu6NmWI7zmIiIiIxF51VyH3/8sfa/J0+eDD8/P5w4cQLt2rXD+PHj9Roc3cvL2QbpucVIyylCD19nqcMhIiJqFhrduHLAgAEYMGCAPmKhevBW2CISOezFREREZET1GpLTZfVbYWEhLl261OCAqHZeCvZiIiIiMrZ6JUxPP/00QkNDsWHDBhQUFFR7zuXLl/H222+jbdu2OHv2rF6DpDu8nCtWynEOExERkfHUa0ju8uXL+O6777BgwQI8+eSTaN++Pby9vWFjY4Pbt28jJiYG+fn5mDRpEvbu3attO0D6562pMOWwwkRERGQsgiiKOjX0OXPmDI4dO4br16+jqKgIrq6u6NmzJ4YNGwYXFxdDxSmZ3NxcKBQKKJVKODk5SR0OIpNuY9K3J+ClsEH4/BFSh0NERGSS9P39rfOk7z59+qBPnz6NvjE1jLfzneaV5So1LC24fzIREZGh8dvWzLg6yGEpE6AWgcw8Nq8kIiIyBiZMZsZCJsDDiSvliIiIjIkJkxnSbMLLXkxERETGwYTJDHlVbsKblsOEiYiIyBh0TpgSEhIMEQfpwMtZs58ch+SIiIiMQeeEKTAwEMOGDcO6detQXMwKhxS8WWEiIiIyKp0TpoiICHTr1g2zZ8+Gp6cnZsyYgdOnTxsiNqqBJ7dHISIiMiqdE6YePXrgiy++QGpqKn766SekpaVh0KBB6NKlC5YtW4abN28aIk66i6bCxO1RiIiIjKPBk74tLS3x0EMPYcOGDViyZAni4uIwd+5c+Pr6YurUqUhLS9NnnHQXzRymrPwSlJarJY6GiIio6WtwwnTmzBm88sor8PLywrJlyzB37lzEx8dj3759SE1NxYQJE/QZJ92lpb01rC1lEMWKjt9ERERkWDpvjbJs2TKsXr0asbGxGDt2LNauXYuxY8dCJqvIvQICArBmzRr4+/vrO1aqJAgCvBQ2uH6rEGnKYvi62EkdEhERUZOmc8L03Xff4dlnn8X06dPh5eVV7Tnu7u748ccfGx0c1exOwsSJ30RERIamc8J09erVOs+xtrbGtGnTGhQQ1Y924jdbCxARERmczgnT+fPnqz0uCAJsbGzQunVryOXyRgdGtfNyZmsBIiIiY9E5YerRowcEQajxdSsrK0yePBkrV66EjY1No4KjmnmywkRERGQ0Oq+S27JlC9q1a4dVq1YhKioKUVFRWLVqFYKCgvDbb7/hxx9/xIEDB7BgwQJDxEuVvI3YvPL300kY8FEYziXnGPxeREREpkjnCtOHH36IL774AqGhodpjXbt2RatWrfDOO+/g9OnTsLe3x5w5c/DZZ5/pNVi6Q7sBr4GbV+aXlOPjv2OgLCrDyiPx+Pap3ga9HxERkSnSucJ04cIF+Pn53XPcz88PFy5cAFAxbMfGlYblXTmHKbugFMVlKoPd57dT16EsKgMA7L+ciZzCUoPdi4iIyFTpnDB16NABH3/8MUpL73xxlpWV4eOPP0aHDh0AACkpKfDw8NBflHQPha0VbK0sAADpBqoyFZep8MPRRACAtaUMpSo1/jrPRJiIiJofnYfkvvnmGzz44INo1aoVunXrBqCi6qRSqbBjxw4AQEJCAl555RX9RkpVCIIAL2cbJNwsQKqyCP6u9nq/x6aIG8jMK4GXwgbTBvrj479jsPHsDTw94N4KIxERUVOmc8I0cOBAJCYm4tdff8WVK1cAAI8++iiefPJJODo6AgCefvpp/UZJ1fJW2CLhZgHSDLBSrlylxsrDCQCAF+5vgwd7eOOzPbE4l5yDuMx8BLo76P2eREREpkqnhKmsrAwdOnTAjh078NJLLxkqJqonLwOulNt5IQ1J2YVoYWeFx/v5ws7aEkOD3LA/OhObIm7gv6M76P2eREREpkqnOUxWVlYoLmbfH1Ph5VzZi0nPc5jUahHfHowHADx7XwDsrCvy6od7tQIAbIlIgUot6vWeREREpkznSd8zZ87EkiVLUF5eboh4SAfaClOOfitMB2IyEZuRB3trC0wN9tceH97RHc52VkjPLcaJ+Cy93pOIiMiU6TyH6Z9//kFYWBj27t2Lrl27wt6+6mTjzZs36y04qt2dITn9VZhEUcQ3h+IAAFOC/aCws9K+Jre0wIPdvbE2/Do2nr2B+9u56e2+REREpkznhMnZ2RkPP/ywIWIhHXlrhuT0WGE6mZCNyKQcWFvK8NyggHtef7hXK6wNv449l9KRV1wGRxurat6FiIioadE5YVq9erUh4qAG0FSYcovLUVBSDnu5zh/nPb6trC491qcV3B3v3QuwWysFAt0dEJeZj10X0jC5b+tG35OIiMjU6TyHCQDKy8uxf/9+rFy5Enl5eQCA1NRU5Ofn6zU4qp2jjRUcK5MkfQzLXbihxNGrWbCQCZgxuG215wiCoJ38velsSqPvSUREZA50TpiuX7+Orl27YsKECZg5cyZu3rwJAFiyZAnmzp2r9wCpdl7O+mstoKkuPdjdG74udjWeN6mnD2QCcPpaNq7fKmj0fYmIiEydzgnT66+/jj59+uD27duwtbXVHp80aRLCwsL0GhzVTbsJbyObV8Zl5mP3pXQAwMtDq68uaXgqbDCocsL3pghWmYiIqOnTOWE6evQoFixYAGtr6yrH/f39kZLCL09j02zCm9rICtOKw/EQRWBkJw+093Cs8/yHe/kAADZH3ICaPZmIiKiJ0zlhUqvVUKlU9xy/ceOGdmsUMh5Pp8ZXmFJyirA1siLZfaWO6pJGaGdPOMotceN2EU5fy27wvYmIiMyBzgnTqFGjsHz5cu1zQRCQn5+PRYsWYezYsfqMjerBSw8Vpu+PJKBcLWJg25bo2bpFva6xsbLAuG5eAICNZ280+N5ERETmQOeEaenSpTh+/Dg6deqE4uJiPPnkk9rhuCVLlhgixiq++eYb+Pv7w8bGBv3798fp06drPHfNmjUQBKHKw8bm3qXy5sxbM4epgavksvJL8PvpJADAK0MDdbr2kd4Vq+X+vpCGwlJ2ficioqZL58Y9rVq1wrlz57B+/XqcP38e+fn5eO655/DUU09VmQRuCH/88Qdmz56NFStWoH///li+fDlCQ0MRGxsLd3f3aq9xcnJCbGys9rkgCAaN0dg0Fab0BiZMq48noqRcje6tFLgvsKVO1/b2awH/lna4dqsQuy+m46HKdgNERERNTYM6HVpaWmLKlCn6jqVOy5YtwwsvvIBnnnkGALBixQrs3LkTP/30E+bNm1ftNYIgwNPT05hhGpWmwpRfUo7c4jI46dB5O7e4DGtPXAcAvDw0UOdkUhAEPNSrFZbtu4JNETeYMBERUZPVoITp6tWrOHjwIDIzM6FWq6u8tnDhQr0E9m+lpaU4e/Ys5s+frz0mk8kQEhKC8PDwGq/Lz8+Hn58f1Go1evXqhY8++gidO3eu8fySkhKUlJRon+fm5urnBzAQW2sLONtZIaewDGk5xXDyrH/CtO7kdeSVlCPQ3QGjOnk06P6Tevpg2b4rOBF/Cyk5RfBxNmyVkYiISAo6J0zff/89Xn75Zbi6usLT07NKVUIQBIMlTFlZWVCpVPDwqPrF7uHhgZiYmGqvCQoKwk8//YRu3bpBqVTis88+w8CBA3Hp0iW0alV9NWTx4sV499139R6/IXkpbJFTWIZUZRGCPOu3UrG4TIWfjiUCAF4e0hYyWcOGKn1d7BDcpiXCE25hS8QNvDq8XYPeh4iIyJTpPOn7gw8+wIcffoj09HRERUUhMjJS+4iIiDBEjA0WHByMqVOnokePHhgyZAg2b94MNzc3rFy5ssZr5s+fD6VSqX0kJycbMeKG8a7cU06X1gJ/nklGVn4pfJxt8WAP70bd/+HKyd+bIlIgiuzJRERETY/OCdPt27fx6KOPGiKWWrm6usLCwgIZGRlVjmdkZNR7jpKVlRV69uyJuLi4Gs+Ry+VwcnKq8jB1ngrdtkcpU6mx8nACAOClIW1gZdGgLQW1xnTxhJ21BRKzChCRlNOo9yIiIjJFOn9TPvroo9i7d68hYqmVtbU1evfuXWX7FbVajbCwMAQHB9frPVQqFS5cuAAvLy9DhSkJ78p5Q6n1rDBtj0pFSk4RXB2s8Wgf30bf315uidFdKpLWTRHsyURERE2PznOYAgMD8c477+DkyZPo2rUrrKyqTjKeNWuW3oL7t9mzZ2PatGno06cP+vXrh+XLl6OgoEC7am7q1Knw8fHB4sWLAQDvvfceBgwYgMDAQOTk5ODTTz/F9evX8fzzzxssRil46VBhUqtFfHc4HgDw3KA2sLGy0EsMj/Rqhc0RKfjrXCoWPtBJb+9LRERkCnROmFatWgUHBwccPnwYhw8frvKaIAgGTZgmT56MmzdvYuHChUhPT0ePHj2we/du7UTwpKQkyGR3ima3b9/GCy+8gPT0dLRo0QK9e/fGiRMn0KlTJ4PFKAXNBrz16cW093IG4jLz4WhjiSkDWusthgFtWsLH2RYpOUXYdzkD47s3bl4UERGRKRFEztKtVW5uLhQKBZRKpcnOZ7p+qwBDPj0EGysZot8bXWM/JVEUMfGb4zh3Q4lXhwVibmiQXuNYujcWXx2Iw9AgN6x5pp9e35uIiEgX+v7+bvBs39LSUsTGxqK8nFtiSE0z6bu4TI2cwrIazzsedwvnbihhYyXDM/f56z0OTePKI1duIjO34ZsBExERmRqdE6bCwkI899xzsLOzQ+fOnZGUVLEP2WuvvYaPP/5Y7wFS3eSWFnB1sAZQ+ya83x6qWB34eN/WaOkg13scAa726O3XAmoR2BKZovf3JyIikorOCdP8+fNx7tw5HDp0qMpGtiEhIfjjjz/0GhzVn2YeU029mCKTbuNE/C1YygS8MLiNweJ4uJemJ9MN9mQiIqImQ+eEaevWrfj6668xaNCgKnNlOnfujPj4eL0GR/VXVy+mbw9VfDaTevoYdPuScd28ILeU4UpGPi6mmPa2MkRERPWlc8J08+ZNuLu733O8oKBA581bSX803b5Tq1kpF5ueh32XMyAIwEtD2xo0DoWtFUZ1Zk8mIiJqWnROmPr06YOdO3dqn2uSpB9++KHeDSRJ/7ycNUNy91aYVlT2XRrTxRNt3RwMHsvDvXwAANuiUlBarq7jbCIiItOncx+mjz76CGPGjMHly5dRXl6OL774ApcvX8aJEyfu6ctExnOneWXVClNydiG2n0sFALwyNNAosdzfzg3ujnJk5pXgQEymtgs4ERGRudK5wjRo0CBERUWhvLwcXbt2xd69e+Hu7o7w8HD07t3bEDFSPWi2R/l3wrTySDxUahGD27uhi4/CKLFYyARM6llRZeKwHBERNQU6V5gAoG3btvj+++/1HQs1gqbClK4shlotQiYTkJlXjD/PVCQsrxh47tK/Pdy7FVYeScDBmEzcyi8xSBsDIiIiY2ncNvVkMjycbCAIQKlKjVsFpQCAH48lorRcjd5+LdA/wMWo8bT3cES3VgqUq0XtkCAREZG5YsLURFhZyODuWFHFSVMWQVlYhnXh1wFUVJekWMGo6cm08SyH5YiIyLwxYWpCPCubV6bmFGNt+DUUlKrQwdMRwzvc2wbCGB7s7g0rCwGXUnMRk86eTEREZL6YMDUhml5MCVn5+Ol4IgDgZYmqSwDQwt4aIzp4AAA2scpERERmjAlTE6LZHuXHo4m4XVgGv5Z2GNfVS9KYHu5dMSy3JTIV5Sr2ZCIiIvNUr1VyDz30UL3fcPPmzQ0OhhrH27miwqSZ9D1jcFtYWkibEw8NckNLe2tk5ZfgyNWbGF5ZcSIiIjIn9UqYFArj9O+hxtFUmADA3VGOh3v7SBhNBSsLGR7s4Y3Vx69h09kUJkxERGSW6pUwrV692tBxkB54VVaYAOCF+9tAbmkhYTR3PNyrFVYfv4Z9lzOgLCyDws5K6pCIiIh0wjlMTUgbV3vYWVvA1UGOJ/q3ljocrc7eTujg6YhSlRp/nWdPJiIiMj8N6vS9ceNG/Pnnn0hKSkJpaWmV1yIiIvQSGOnO2c4aO14bBFtrCzjIG/TRGoQgCHikdyt8sDMamyJuYMoAP6lDIiIi0onOFaYvv/wSzzzzDDw8PBAZGYl+/fqhZcuWSEhIwJgxYwwRI+mgjZtDlblMpmJCDx9YyAREJuUg/ma+1OEQERHpROeE6dtvv8WqVavw1VdfwdraGm+99Rb27duHWbNmQalUGiJGagLcHOUY0t4NAHsyERGR+dE5YUpKSsLAgQMBALa2tsjLywMAPP300/j999/1Gx01KZqtUrZEpkClFiWOhoiIqP50Tpg8PT2RnZ0NAGjdujVOnjwJAEhMTIQo8kuQajaiozsUtlZIUxYjPP6W1OEQERHVm84J0/Dhw7F9+3YAwDPPPIM333wTI0eOxOTJkzFp0iS9B0hNh42VBcZ3r+g8vvFsssTREBER1Z8g6lgWUqvVUKvVsLSsWIW1fv16nDhxAu3atcOMGTNgbW1tkEClkpubC4VCAaVSCScnJ6nDMXuRSbcx6dsTsLGS4Z//C4GjDXsyERGR/un7+1vntecymQwy2Z3C1OOPP47HH3+80YFQ89DD1xlt3OyRcLMAf19Ix2N9faUOiYiIqE71SpjOnz+PLl26QCaT4fz587We261bN70ERk2TIAh4uFcrfLonFhsjbjBhIiIis1CvhKlHjx5IT0+Hu7s7evToAUEQqp3gLQgCVCqV3oOkpuWhXj74bG8sTidmI+lWIVq3tJM6JCIiolrVK2FKTEyEm5ub9r+JGsNLYYtBga44ejULmyJu4M2R7aUOiYiIqFb1WiXn5+cHQRAAANevX4ePjw/8/PyqPHx8fHD9+nWDBktNh6Yn0/p/kpBbXCZxNERERLXTua3AsGHDtH2Y7qZUKjFs2DC9BEVN3+gunvBraYeM3BL8b/slqcMhIiKqlc4JkyiK2mrT3W7dugV7e3u9BEVNn42VBZY91h0yAdgckYLdF9OkDomIiKhG9W4r8NBDDwGomNg9ffp0yOVy7WsqlQrnz5/XbplCVB+9/Vzw0pC2+PZQPN7echG9/FrA3dFG6rCIiIjuUe8Kk0KhgEKhgCiKcHR01D5XKBTw9PTEiy++iHXr1hkyVmqC3ghpj45eTsguKMX8TRe4vQ4REZmkeleYVq9eDQDw9/fH3LlzOfxGemFtKcPyyT0w/qtjCIvJxB//JOPxfq2lDouIiKgKnecwLVq0iMkS6VWQpyPmhla0Fnh/x2Uk3SqUOCIiIqKqdE6YMjIy8PTTT8Pb2xuWlpawsLCo8iBqiOcGtUG/ABcUlKowZ0MUVGoOzRERkenQeS+56dOnIykpCe+88w68vLyqXTFHpCsLmYClj3bH6OVH8M+12/j+aAJeGtJW6rCIiIgAAIKo4yxbR0dHHD16FD169DBQSKZF37sdU+3+/CcZb206D2sLGba9eh86evHPnIiIdKfv72+dh+R8fX25kokM5tE+rRDS0QOlKjXe/CMKJeXcm5CIiKSnc8K0fPlyzJs3D9euXTNAONTcCYKAjx/uipb21ohJz8Pn+65KHRIREZHuQ3ItWrRAYWEhysvLYWdnBysrqyqvV7dtijnjkJw09lxKx4xfzkIQgD9nBKOvv4vUIRERkRnR9/e3zpO+ly9f3uibEtUltLMnHundChvP3sCcP89h1+v3w0Gu8/+uREREeqFzham5YYVJOnnFZRi9/ChScorwRD9fLH6om9QhERGRmZB80jcAxMfHY8GCBXjiiSeQmZkJAPj7779x6RJ3nSf9cbSxwmePdocgAL+fTsaBmAypQyIiomZK54Tp8OHD6Nq1K06dOoXNmzcjPz8fAHDu3DksWrRI7wFS8xbctiWeuy8AAPDWxgvILiiVOCIiImqOdE6Y5s2bhw8++AD79u2DtbW19vjw4cNx8uRJvQZHBABzQ4PQzt0BWfkl+L8t3KCXiIiMT+eE6cKFC5g0adI9x93d3ZGVlaWXoIjuZmNlgc8n94ClTMDfF9OxNSpF6pCIiKiZ0TlhcnZ2Rlpa2j3HIyMj4ePjo5egavPNN9/A398fNjY26N+/P06fPl3r+Rs2bECHDh1gY2ODrl27YteuXQaPkfSvi48Cb4S0AwAs3HYJqTlFEkdERETNic4J0+OPP47//ve/SE9PhyAIUKvVOH78OObOnYupU6caIkatP/74A7Nnz8aiRYsQERGB7t27IzQ0VDvx/N9OnDiBJ554As899xwiIyMxceJETJw4ERcvXjRonGQYLw1pi56tnZFXXI65G85BzQ16iYjISHRuK1BaWoqZM2dizZo1UKlUsLS0hEqlwpNPPok1a9bAwsLCULGif//+6Nu3L77++msAgFqthq+vL1577TXMmzfvnvMnT56MgoIC7NixQ3tswIAB6NGjB1asWFGve7KtgGlJzCrA2C+OoqhMhYUPdMKzgwKkDomIiEyQ5G0FrK2t8f333yMhIQE7duzAunXrEBMTg19++cWgyVJpaSnOnj2LkJAQ7TGZTIaQkBCEh4dXe014eHiV8wEgNDS0xvMBoKSkBLm5uVUeZDoCXO3x9riOAIAlu2MQl5kncURERNQc6JwwvffeeygsLISvry/Gjh2Lxx57DO3atUNRURHee+89Q8QIAMjKyoJKpYKHh0eV4x4eHkhPT6/2mvT0dJ3OB4DFixdDoVBoH76+vo0PnvRqSv/WGNLeDSXlarz5xzmUqdRSh0RERE2czgnTu+++q+29dLfCwkK8++67eglKSvPnz4dSqdQ+kpOTpQ6J/kUQBHzySDcobK1wIUWJrw7ESR0SERE1cTonTKIoQhCEe46fO3cOLi6G2yDV1dUVFhYWyMio2u05IyMDnp6e1V7j6emp0/kAIJfL4eTkVOVBpsfDyQYfTOwCAPjmYByiknOkDYiIiJq0eidMLVq0gIuLCwRBQPv27eHi4qJ9KBQKjBw5Eo899pjBArW2tkbv3r0RFhamPaZWqxEWFobg4OBqrwkODq5yPgDs27evxvPJvIzv7o0Hu3tDpRYx+48oFJWqpA6JiIiaqHpv/758+XKIoohnn30W7777LhQKhfY1a2tr+Pv7GzwRmT17NqZNm4Y+ffqgX79+WL58OQoKCvDMM88AAKZOnQofHx8sXrwYAPD6669jyJAhWLp0KcaNG4f169fjzJkzWLVqlUHjJON5f0IXnEq8hYSsAnz8dzTendBF6pCIiKgJqnfCNG3aNABAQEAABg4cCCsrK4MFVZPJkyfj5s2bWLhwIdLT09GjRw/s3r1bO7E7KSkJMtmdotnAgQPx22+/YcGCBXj77bfRrl07bN26FV268Eu1qVDYWeHTR7pj6k+n8XP4dYR08sD97dykDouIiJoYnfswAYBKpcLWrVsRHR0NAOjcuTMefPBBg7YVkAr7MJmHhdsuYm34dXg62WDPG4OhsDN+Qk9ERKZD8j5McXFx6NixI6ZOnYrNmzdj8+bNmDJlCjp37oz4+PhGB0TUEPPHdEQbV3uk5xZj4XZ2ciciIv3SOWGaNWsW2rZti+TkZERERCAiIgJJSUkICAjArFmzDBEjUZ1srS2w9LHusJAJ2BaViqNXb0odEhERNSE6J0yHDx/GJ598UqWFQMuWLfHxxx/j8OHDeg2OSBc9W7fAE/0qGo1ui0qVOBoiImpKdE6Y5HI58vLu3Y4iPz8f1tbWegmKqKHGdfUGAIRFZ6CcHcCJiEhPdE6YHnjgAbz44os4deoURFGEKIo4efIkXnrpJTz44IOGiJGo3vr6t0ALOyvcLizD6WvZUodDRERNhM4J05dffom2bdsiODgYNjY2sLGxwX333YfAwEB88cUXhoiRqN4sLWQI6VjRZmLvpYw6ziYiIqqfevdh0nB2dsa2bdsQFxenbSvQsWNHBAYG6j04ooYI7eyJDWdvYO+ldCwa36narXyIiIh0Ue+ESa1W49NPP8X27dtRWlqKESNGYNGiRbC1tTVkfEQ6G9TOFXbWFkhVFuNCihLdWjlLHRIREZm5eg/Jffjhh3j77bfh4OAAHx8ffPHFF5g5c6YhYyNqEBsrCwwNquj2vedSusTREBFRU1DvhGnt2rX49ttvsWfPHmzduhV//fUXfv31V6jVXIlEpie0sycAYA/nMRERkR7UO2FKSkrC2LFjtc9DQkIgCAJSU9nvhkzPsA7usLIQEJeZj7jMfKnDISIiM1fvhKm8vBw2NjZVjllZWaGsrEzvQRE1lpONFYLbugLgsBwRETVevSd9i6KI6dOnQy6Xa48VFxfjpZdegr29vfbY5s2b9RshUQOFdvbAkSs3sfdSOmYO4ypOIiJquHonTNOmTbvn2JQpU/QaDJE+jezkgQVbL+LcDSXSlEXwUnBFJxERNUy9E6bVq1cbMg4ivXN3tEGv1i1w9vpt7L2UgWkD/aUOiYiIzJTOnb6JzElo54qu35zHREREjcGEiZo0TXuBU4nZuF1QKnE0RERkrpgwUZPm19IeHTwdoVKLCIvJlDocozh2NQvpymKpwyAialKYMFGTN0rbxLLpD8udiMvClB9P4eVfz0odChFRk8KEiZo8zTymI1duorC0XOJoDOvQlZsAgMikHCRnF0ocDRFR08GEiZq8Tl5OaNXCFiXlahypTCiaqvD4W9r/3nuZ28IQEekLEyZq8gRBaBZ7yymLynApVal93hyGIImIjIUJEzULmoQpLDoDZaqmuWH0P4nZUItAS3trAMCZa9m4lV8icVRERE0DEyZqFnr7tUBLe2vkFpfjZMKtui8wQ5qfa1RnT3TxcYJaBPZHN92KGhGRMTFhombBQiZgZKem3cQyvDJhGtDGBaGdmv4QJBGRMTFhomZDMyy391IG1GpR4mj0S1lYhstpuQCA4DYtEdql4mc9djUL+SVNe2UgEZExMGGiZmNgYEs4yC2RmVeCqBs5UoejV6cSb0EUgTZu9nB3skE7dwcEuNqjVKXGodjm0bCTiMiQmDBRsyG3tMDQIDcATW9Y7mRCNgBgQJuWACpWBo7S7qPHYTkiosZiwkTNyt3DcqLYdIblNPOXgisTJuDOz3owJhMl5SpJ4iIiaiqYMFGzMjTIDdYWMiRmFeBqZr7U4ehFTmEpYtIr5i/1b+OiPd6jlTPcHeXILynHifimuTKQiMhYmDBRs+JoY4X7AiuqMHsuNo1huVOJ2RBFINDdAe6ONtrjMtmdYbm9TWwIkojI2JgwUbOj7fp9uWkkEZrtUAbcVV3S0Pys+y5nQNXEVgYSERkTEyZqdkI6eUAmABdTcnHjtvlvUHtSO3/J9Z7XBrRpCScbS2TllyIi6baxQyMiajKYMFGz4+ogRx+/imrMXjNfQZZdUIqY9DwAVecvaVhZyDCiY+VquSYyBElEJAUmTNQs3Vlyb95JxOnEiupSO3cHuDrIqz1nlKbD+eX0JrUykIjImJgwUbOkmdvzj5lvUKuZvxTctmWN5wwJcoPcUobk7CJEp+UZKzQioiaFCRM1S74udujkVbFBbVi0+XbC/nfDyurYWVvi/nZNs2EnEZGxMGGiZku7Ws5Mk4hb+SWIzaicvxRw7/ylu4U2kSFIIiKpMGGiZiu0S0UScTTOPDeoPZVYUV0K8nBEyxrmL2mEdPSAhUxATHoekm6Z/8pAIiJjY8JEzVaQhyP8WtqhtFyNw7E3pQ5HZ9p2ArXMX9JoYW+Nfv4VVShWmYiIdMeEiZotQRDMeliutoaV1eGwHBFRwzFhomZNk0QcjMlEabla4mjqLyu/RLsXXv+AuitMADCqMjk8m3QbN/PMd2UgEZEUmDBRs9bTtwXcHOXIKynHifgsqcOpN81wXAdPR7Swt67XNd7OtujWSgFRBPZHm3fDTiIiY2PCRM2aTCZgpKaxoxl1/dZl/tLdzHkIkohISkyYqNkzxw1q78xf0jVhqkgOT8TdQl5xmd7jaqrOXMvG0E8PYt3J61KHQkQSYcJEzV5wm5ZwtLFEVn4JIs1gg9rMvGLE3yyAINTdf+nfAt0d0cbNHqUqNQ6a4cpAKWTkFuOldRG4dqsQS3bHIJeJJlGzxISJmj1rSxmGd3AHYB5DVZru3h09neBsV7/5S3fjsFz9lanUmPlrBLIqt8/JKy7HL+GsMhE1R0yYiHB3EpFh8hvUauYv6Tocp6H5WQ/FZKK4TKW3uJqij3ZF48z123CUW+KNkHYAgB+OJqCw1PwanRJR4zBhIgIwpL0brC1lSMouREy6aW9Qe7IeG+7WppuPAp5ONigoVZnVykBj234uFauPXwMALH2sO14dFojWLna4XViG304lSRscERmd2SRM2dnZeOqpp+Dk5ARnZ2c899xzyM/Pr/WaoUOHQhCEKo+XXnrJSBGTObGXW2JwO1cApj1UlZFbjISsivlLms7dupLJBIzSNLG8aD4rA43pSkYe/rvxPADglaFtMaqzJywtZHhlaFsAwMojCazOETUzZpMwPfXUU7h06RL27duHHTt24MiRI3jxxRfrvO6FF15AWlqa9vHJJ58YIVoyR6PuGpYzVZrhuM7eTlDYWTX4fTTDcvujzWdloLHkFZfhpV/OoqhMhUGBrpgzKkj72kO9WsFLYYObeSXYcPaGhFEaV7lKjWk/ncbD351gokjNllkkTNHR0di9ezd++OEH9O/fH4MGDcJXX32F9evXIzU1tdZr7ezs4OnpqX04OTkZKWoyNyEdPSATgOi0XCRnm+YGtdr5S/Xs7l2TfgEuUNha4VZBKc5cy9ZHaE2CKIqYu+EcErIK4K2wwReP94CFTNC+bm0pw0tDKqpMKw7Fo0xlPt3hG2PNiWs4fOUmzl6/jU0RzSdRJLqbWSRM4eHhcHZ2Rp8+fbTHQkJCIJPJcOrUqVqv/fXXX+Hq6oouXbpg/vz5KCys/YuwpKQEubm5VR7UPLjYW6NfgGlvUKtZIdfQ+UsaVhYyjOioWRlouhU1Y1t5JAF7LmXA2kKGb6f0RksH+T3nTO7rC1cHOVJyirAlMkWCKI0rTVmEz/dd0T7/4Wgi1KxKNkuZecUoKGm+Cx7MImFKT0+Hu7t7lWOWlpZwcXFBenrNX2xPPvkk1q1bh4MHD2L+/Pn45ZdfMGXKlFrvtXjxYigUCu3D19dXLz8DmQdTXnKfrixGYlYBZALQV8f+S9W5+2c19ZWBxnAiLguf7I4BACx6sBN6+DpXe56NlQVeHBwAAPj2YFyTH9J8f8dlFJSq0N3XGU42lkjMKsA+E99aZ/fFdOy+aHq/w+Yot7gMf/yThMdWhqPfh2EY9tkhnKqsdDc3kiZM8+bNu2dS9r8fMTExDX7/F198EaGhoejatSueeuoprF27Flu2bEF8fHyN18yfPx9KpVL7SE5ObvD9yfxo5jGduW56G9RqhuO6+CjgZNPw+Usag9u5wcZKhpScIlxKbd6V1DRlEV77PRJqEXi4Vys82a91rec/1d8PznZWuHarEDvO1z4twJwdis3ErgvpsJAJ+PihrpgywA8AsOpIgsSR1Sw6LRcvrTuLl9adxfkbOVKHY5bKVGociMnAq79FoO8H+/HfTRdwOrGiup2ZV4InfziF7w7FN7tKo6QJ05w5cxAdHV3ro02bNvD09ERmZmaVa8vLy5GdnQ1PT896369///4AgLi4uBrPkcvlcHJyqvKg5sPH2RZdfUxzg9qGbodSE1trCwxp7wYA2GuCFTVjKS1X45VfI3CroBSdvJzw4aQuEASh1mvs5ZZ49j5NlalpfnEUl6mwcNslAMAzA/3R0csJ0wf6w9pChrPXb+PsddOc+/b1gTt/v3+wI5rV03oSRREXbijx7l+XELw4DM+uOYMd59NQUq5GO3cHvDU6CGFzhuChnj5QqUUs2R2DF9aeQU5hqdShG42llDd3c3ODm5tbnecFBwcjJycHZ8+eRe/evQEABw4cgFqt1iZB9REVFQUA8PLyalC81DyEdvbAhRQl9lxKxxN1VBqM6WSiJmFq/HCcRmhnT+y5lIE9lzIw+67VYM3JBzsvIzIpB042llgxpTdsrCzqdd20gf74/kgCYjPysC86QzvE2VR8ezAOSdmF8HSywRsj2wMA3J1sMKmnD/44k4yVhxOwaqr+/l/UhysZedh1MQ1AxQT909eysedSBkZ3aVqfjT6l5hRha1QKtkSk4GrmnVY9rg7WGN/dGw/1bIUuPk7af0Qsfaw7+ga4YNH2SwiLycS4L4/hm6d61TiE3ZSYxRymjh07YvTo0XjhhRdw+vRpHD9+HK+++ioef/xxeHt7AwBSUlLQoUMHnD59GgAQHx+P999/H2fPnsW1a9ewfft2TJ06FYMHD0a3bt2k/HHIxGm++I7HZZnMvmGpOUW4fquwYv5SA/svVWdEBw9YygTEZuThWlaB3t7XXGyJvIG1lVudLH+8B1q3tKv3tQpbK0wdWDFE9fWBuCZVyUi4mY8VhyuG3RaO7wQH+Z1/W79QOX9rX3QGEm7W3gvP2Co+B2B0Z0/MGNwGAPDx39EoLW8eqxnrK7+kHBvP3sCT35/EfUsO4JPdsbiamQ9rSxke6OaFn6b3Qfj8EVg0vjO6tlJUqbgKgoAn+rXGllcGwq+lHVJyivDoihP4+cS1JvU7UB2zSJiAitVuHTp0wIgRIzB27FgMGjQIq1at0r5eVlaG2NhY7So4a2tr7N+/H6NGjUKHDh0wZ84cPPzww/jrr7+k+hHITAS6O6CNqz3KVCIOxmTWfYERaOYvdfVRwFEP85c0FHZW2iE+U5zobkjRabmYv/kCAGDWiHYY3sFD5/d49r4A2FpZ4EKKEoevNI3NjEVRxMJtl1CqUmNIezeM+Vd1JtDdESM6uEMUgR+OJUoU5b3iMvPxV+V8stdGBGLGkLZwdZDj2q1CrDvJ/f9UahGHr9zEG+sj0eeDfZi74RxOxN+CKFa0GVnycFecWRCCr5/sheEdPGBlUXt60Nlbgb9eG4QxXTxRphKxaPslvPp7JPJM5B+ZhiDpkJwuXFxc8Ntvv9X4ur+/f5Xs1tfXF4cPHzZGaNTECIKAUZ09seJwPPZeysCEHj5Sh3Sn/1Ij2wlUJ7SzB47FZWHPpXTMqOwx1NQpi8rw0rqzKC5TY3B7N7w+ol2D3qelgxxP9m+NH48l4usDcRjS3q3O+U+m7q/zaTgWlwVrSxnem9C52p/nxcFtEBaTiY1nb2D2yPZwrab9grF9e7CiuhTS0QOdvRUAgLmj2mPe5gv4IuwqHurl06DNqs1ddFouNkfcwLaoVGTetZCljas9JvX0wcSePvB1qX9l9W5ONlb49qleWH38Gj7aFY2d59NwOTUX3z7VCx29mt78X7OpMBEZU2jl1iGHYk1jg9rwRm64W5uRnSoqCBFJOcjMLdb7+5satVrEnD+jcP1WIXycbfHF5KrNKXX14uA2sLaQ4cz12ziVaJoToesrt7gM7++4DACYOTQQfi3tqz2vX4ALuvs6o7RcjbUnrhkxwupdyyrA1qiKnlizRgRqjz/axxcdPB2hLCrDVwdqXuzT1GQXlOL7IwkYvfwIxnxxFN8fTURmXgmc7awwNdgPW14ZiLA5Q/DaiHYNTpY0BEHAs4MC8OdLwfBW2CAxqwATvzmOP880vRXmTJiIqtG9lTM8nOQoKFXheJy0G9TeuF2I5OwiWMgEvc5f0vBU2GgnbO69bForAw3hu8Px2B+dCWtLGVZM6Y0W9o2rOng42eCxvq0AVF2hZY6W7b2Cm3klCHC1x0tD29R4niAI2jlCa09eR2GptM0MvzkYB7UIDAtyQ7dWztrjFjIBb4/tCABYG36tyc/Tu3G7EP/bfgn3fXwAH+6KRkx6HqwtZBjTxROrnu6N02+H4L0JXdCzdQu9V0J7tW6BnbPux9AgN5SUq/HWxvOYu+Ecikql/wenvjBhIqqGTCZgVCfTaGKp6e7d1UdRZfKtPplyw059Onr1Jj7bGwsAeH9CxYRWfZgxuC0sZQKOxWUhIum2Xt7T2C6mKLE2/BoA4P0JXSC3rH21YGhnT7R2sUNOYRk2nJFuu5Tk7EJsruy4/lo1Q6uD27thSHs3lKlEfPx3w/v6mbLY9DzM/iMKQz89hDUnrqGoTIXO3hUtMk7/3wh8N6U3RnX2hLWlYb/yW9hb46dpffGf0CDIBGDj2RuY9O1xxJvY4oCGYsJEVIM7G9RmolzCPcM085caux1KbTRDkOHxt6AsapqTNlNyijDr90iIIvB4X19M7qu/lhG+LnaY1LNirts3ZlhlUqlF/N/Wi1CLwPju3hjUzrXOayxkAp6/v2LF3A/HEiT7Hfn2UEW39fvbuaJX6xbVnvN/4zpCJgC7L6VrGzA2BWeuZeP5n/9B6PIj2ByZgnK1iPsCW2Ldc/2x47VBlQ1WjTtvSyYTMHNYINY93x+uDnLEpOfhwa+O4a9z5t/glQkTUQ36t6nYoDa7oBRnrktXNdB3w8rqtHFzQDt3B5SrTWdloD4Vl6nw8rqzuF1Yhq4+Cvzvwc56v8fLQ9tCJgBhMZm4lKrU+/sb0u+nk3AuOQcOckssGNex3tc92tsXLeyskJxdJMmehDduF2Lj2YrqVm0T99t7OOLxyp5qH+68bNaNRkVRxIGYDDy64gQeWRGO/dGZEARgTBdPbJt5H359fgAGtXOVfPHBwLau2PX6IAxo44KCUhVe+z0SC7ddREm5+Q7RMWEiqoGVhQwjOmg2qJVmqCo5uxApOUWwlAno41f9v571pSkPy73712Wcv6GEs13Fqp76NqfURRs3B4zrVtEX7tuDNW+/ZGqy8ku0e+jNGdUeHk429b7W1toCTwf7AwBWHYk3eh+eFYfjUaYSMbBtS/SpY37fmyHtYW9tgXM3lNr2A+akTKXGlsgbGPPFUTy75gz+uXYbVhYCHu/ri7DZQ/DdlN7obmLNI90dbbDuuf6YOaxi9e3a8Ot4bEU4krMLJY6sYZgwEdVCs7fc3ksZkjRl06yO69ZKAXsDzV/S0CRMh2JvmsTKQH3580wyfj+dBEEAvni8Z6NXBdVG88Ww62Ia4jLzDHYfffpoVzRyi8vR2dsJT1fuFaeLacF+kFvKcO6G0qirBNOURfjzn4rq0qx6tIVwc5TjlWEVK+iW/B1jNv+PF5Wq8POJaxj66SG8+cc5xKTnwd7aAjMGt8Gx/w7Hxw93Qxs3B6nDrJGlhQz/Ce2A1dP7wtnOCuduKDHuy6PYb4YLTJgwEdViSHtpN6g9acB2Av/WxccJPs62KCpT4ehVaVcG6svFFCXe2XoRQEWFQbN3nqF08HTCqE4eEEXzqDKdTLiFzREpEATgg4ldYFlHs8LqtHSQ45HeFasEjbkp78rDCShVqdEvwKXevx/PDQqAj7MtUpXF+NGEmm5WJ6ewFF+GXcV9Sw5g0fZLSMkpQkt7a/wnNAgn5o3A/LEddaoGSm1YB3fsnHU/evg6I7e4HM+vPYPFf0dLOj9UV0yYiGpha22Bwe0qvmSNPVQliiJOVa6QM+SEbw1BEDCyU8Xk76YwLJdTWIqXfz2LknI1hndwx6vDAuu+SA9eHV5xn23nUnH9lukuYy8tV2NBZTL5RL/W6FnDhOn6eP7+NhAE4EBMJq5mGL6ylplbjN9OJwGofe7Sv9lYWeA/oRV7Jn53KB4372rkaCrSlEX4YMdlDPz4AJbtu4LsglL4utji/YldcHzecMwcFgiFnf66/RuTj7Mt/pwRjGfu8wdQkfQ++f0ppCvNo/8bEyaiOmiGqjZHpBi1jJ+cXYSUnCJYWQjobeD5SxqanzUsOsOs/uX3b2q1iDf/iEJydhFau9jh88d6QNaI5pS66NbKGUPau0GlFrHisOlWmX48loi4zHy0tLfGf0M7NOq9AlztMaoy2TZGlWnlkQSUlqvR268FBur4j4kHu3ujWysF8kvK8fn+KwaKUHdxmfn4z4ZzGPzJQfxwLBGFpSp09HLCF4/3wME5Q/H0AD+DzL0zNmtLGRaN74xvn+oFB7klTl/Lxrgvj+KYGVS1mTAR1WF0F094OtkgJacIXx24arT7aobjurdyhp21cXYx6uvfAi3srHC7sAynr5nv8uuvDsThYOxNyC1l+G5KL6P/i/y1yirTxrM3kKYsMuq96+PG7UJ8GVbx//LbYzvq5c/nxcEV87e2RqUYtGP8zbwS/HqqYm+4WSPa6bwaTCYTsGBcJwDA+tNJuGKEilhtLtxQYsYvZzDy88PYcPYGylQi+ge4YM0zfbFr1iBM6OHToKFSUze2qxd2vDYIHb2ccKug1Czm/DW9T4FIz+zlltpl6CsPJyA23Ti/2IbcDqUmlhYyhHSsqBTslWCZeF1EUURxmQrZBaW4cbsQVzPycC45ByfisxAWnYG/zqXiu0PxWB5WUTn4cFJX7b5ixtTH3wX9A1xQphKx8rDx5vXU1/+2X0ZRmQr9AlzwUC/97JXY268F+vi1QJlKxGoDbpfyw9EEFJep0d3XGYPr0S+qOv0CXDC6syfUYsWkd6nsPJ+Gid8ex55LGRBFYFQnD2x+ZSD+mBGMoUHukrcGMDR/V3tseWUgPprUFdMG+ksdTp3MZvNdIimN7uKJkZ08sO9yBt7ecgEbZgQbdIhHFEWjNKysTmhnT2w4ewN7L6Vj0fhOBvtLu7C0HFsiU5CRW4LCknIUlqlQVKpCYWk5CktV2kdRaTkKSu+8Vt8WOk/1b62djCyF14a3w6kfT+H300mYOSwQbo7Sb1ALAPsuZ2B/dAYsZQI+mNhFr5/vi4Pb4MwvZ7Hu5HXMHBao9870t/JLsDa8orr0+ojARsU+b0wHhMVk4FDsTRy5chODDbwg4N+2n0vFm39EQaUWEdLRA/PGBCHQ3dGoMZgCGysLPNlff01kDYkJE1E9vftgZ5yIy8LZ67fx+z9JeKq/7kuw6+v6rUKkKYthZSHU2L3YUAa1c4WdtQVSlcW4kKKssjeXPoiiiN0X0/H+jstIbcRkT7mlDHbWFrCztoSttQXsrS1gW/m8k5cTXhthnEneNbkvsCV6+DojKjkHPxxLwPwx9W8IaSiFpeX43/ZLAComarf30O8XdEhHD7Rxs0fCzQKsP52E5++veT+6hvjxWCKKylTo4uOEYUHujXovf1d7TA32x4/HEvHRrmjcF+jaqE2YdbE1MgWz/4yCWgQe6d0KSx7uZrR7U8MxYSKqJ29nW8wZFYT3dlzGx3/HYGRHD7gbaFmvprrU07cFbK2NO9HTxsoCQ4PcsOtCOvZeytBrwpSYVYBF2y/hyJWbACpWzQzr4AZ7bdJjWZn0WGiTIbu7EiFNUmRrZWHy8zoEQcBrwwPx3M9nsC78Ol4e0tbo21T821cH4pCSUwQfZ1vMMkBCKZMJeOH+Npi/+QJ+OpaIaQP9YaWnzymnsBQ/Vw71zRqu+9yl6rw2PBAbz95ATHoeNpxJ1nYDN6SNZ2/gPxvPabfo+WhSV6MtSKDGYcJEpINpA/2xNSoF528o8e6Oy/jmyV4Guc+d+Uu1dy82lNDOnth1IR17LqVjbuUy7MYoKlXhm4NxWHWkoneOtYUMLw1pg5eHBho9ITSm4R3c0dHLCdFpuVh9/BreHNlesliuZuTh+8oVbIvGdzLYQoJJPX2wdG8sUpXFFXN0eupnjtRPxxJRULlyTNP+orGc7awxa0Q7vL/jMpbuu4Lx3b0N2iD2j3+SMG/zBYhixZDx+xO6MFkyI6b9TzQiE2MhE/DRpK6wkAnYeT7NIPuu3T1/yZgTvu82rIM7rCwEXM3MR0IjdhoXRRF7LqUjZNlhfH0wDqUqNYa0d8OeNwdj9qigJp0sAXeqTACw+ngi8oql2dhYFEUs2HoR5WoRIR3dtR3sDcHGygLTKrdLWXkkQS8d8pVFZVh9/BoAYNbwxs1d+renB/jBv6UdbuaVYKUB20D8dioJ/91UkSxNC/bDBxOZLJkbJkxEOurio8CzlY3XFmy9iMLScr2+f2JWATJyS2BtIUMvI/Vf+jcnGysEt61YgdTQTVWvZRXgmTX/YMYvZ7XDQCuf7o01z/RFgKu9PsM1aaM7e6Ktmz1yi8vxy8nrksSwJTIFpxKzYWNV0QPH0KYM8IOtlQWi03JxPO5Wo99vzfFryCspR5CHo7ZXmL5YW8owr3J+2aqjCQZpA7E2/Bre3nIBAPDsfQH434Odm/wKuKaICRNRA7wR0h4+zrZIySnC8v367c10srK7d4/WzpI2qgvt3LCu38VlKizbG4tRnx/BodibsLIQMHNYW+ybPRihnT2b3ReFTCZgZmWX8R+OJuo9wa6LsrAMH+6sWDo/a0Q7g+6lp9HC3hqT+/oCAFYeaVzVJq+4DD8eqxhKfG1EoEGqMqGdPdDP3wXFZWp8uidWr+/907FELNxWMdH+xcFt8M4DHZvd70BTwYSJqAHs5ZZ4f2LFv9R/PJaIS6lKvb23tp2ARMNxGiM7eUAQgKjknHpvXbD/cgZClh3Glwcqht/ub+eKPW8Mxn9COxit+aYperC7N3xdbJFdUIrfTycb9d6f7InBrYJSBLo74PlB+l21VpvnBgVAJgBHr2bhciP2YVwbfh25xeUIdHfAmC5eeozwDkEQsOCBiirT5ogUXLihn9/nH44m4L0dlwEALw9ti/ljOjBZMmNMmIgaaHgHD4zr6gWVWsTbmy9AVd8GQbUQRVGShpXVcXe00bY02He59ipT0q1CPLfmHzy/9gxu3C6Cl8IG3z3VC2uf7WfSO6kbi6WFDK8MragyrToSj5Jy42yxE5Wco91z7f0JXWBtaby/8n1d7DC2a0WC8/3RhjXvzC8p11772vBAgy6979bKGZMqJ6h/sPNyo+defXcoHh9oKnvDA/FWaBCTJTPHhImoERaN7wRHuSXO3VDil/BrjX6/hKwC3MwrgbWlDD1bOzf6/RprlHYz3urnMRWXqbB8/xWEfH4YYTGZsLIQ8PLQttg/ewjGdPXiF8RdHurlAy+FDTJyS7Dx7A2D369cpcb/bamYZPxQTx+jN0AFKoagAOCvc6lIzdF9btC6k9eRU1iGNq72eKCbt77Du8d/QoMgt5ThVGI29l1ueKf7rw9cxZLdMQCAN0PaY/YoJktNARMmokZwd7LBW2MqNi79dE9soyeMhsdXVJd6STx/SUMzwfZkwi0oC6uu8DoQk4FRnx/B8v1XUVquxn2BLfH364Px39EdDLo021zJLS20CcR3h+JRZuDNjdedvI5LqblwsrHE/LHSNM3s1soZA9q4oFwt4qdjiTpdW1harm2DMHOYYatLGt7Otnj+/gAAwMd/xzToM1q+/wo+21uxNc/cUe3xekg7vcZI0mHCRNRIT/VrjV6tnVFQqsKiysmdDXVn/lLD9sjSN39XewR5OKJcLSIspuJf3MnZhXhh7Rk8u+YMkrIL4eEkx9dP9sS65/oj0J3Db7V5vG9ruDpY48btImyLSjXYfTJzi7G08kv7P6M7SLoty4zKTXl/P50EZVH92yr8dioJtwpK0drFDhN6GL66pPHy0EC4OlgjIasAv+qwqlEURSzdG6tdBPLf0R3w6nAmS00JEyaiRpLJBCx+qBssZQL2Xs7QeVWZRkX/pYoVclI1rKyOZrXcjvNp+CrsKkKWHca+yxV7kc0Y3AZhc4bigW7eHHKoB1trC+12Id8ejNPLvLfqvL8zGnkl5ejeSoEnjdC9ujZDg9zQ3sMBBaUq/F45n6ouxWUqrKjctPjVYYFG7eruILfE7JEVzVqXh129p7JaHVEU8cmeWHx1IA4AsGBcR7w8tK1B4yTjY8JEpAdBno7a4Zb/bb+E/BLdl47H38xHVn4J5JYy9DCB+UsamiaHB2IysXTfFZSUqxHcpiX+fv1+zB/bUe8brDZ1Uwb4QWFrhYSsAuy6kNao9ypXqXEtqwBh0RlYdSQeb208h4e+PY6/zqVCJgAfTOwq+R5lglCxXQpQ0byztLzuYa7fTychK78EPs62mNRLP53CdfFYn1Zo7+GAnMIyfH2w9rYhoihi8d8x+O5QRfuEReM76X0PPTIN/JuOSE9mjWiHHefTkJRdiM/2xOJ/D+rWIFAzf6m3XwvILaWfv6TR2dsJfi3tcP1WIdwd5VjwQCeM78YJ3Q3lILfEs/cF4PP9V/DNwTiM6+pVZ2+hgpJyxN/Mr3hkFmj/+1pWIUprmGfz0pC26NpKYYgfQWcTevjgs72xyMgtwbaoFDzax7fGcyuqSxXJx8xhgXrbi04XlhYyvD22I6av/gc/n7iOKQP84Nfy3maroijivR2XtV3I35vQGVMru5xT08OEiUhPbKws8OGkLnj6x9P4OfwaJvX0QXdf53pff2c4Ttp2Av8mCAJWPt0bZ67dxoQe3nC0sZI6JLM3faA/vj+agJj0PITFZGJkJw+IooiM3JK7EqN8xN+sSI7SaumDJbeUoY2bA9q62SPQ3QFt3RzQ3sMRQZ6ORvyJamdtKcP0gQFYsjsG3x9NwCO9W9WYcG84k4yM3BJ4K2zwcG/jV5c0hga5Y3B7Nxy5chNLdsfg26d6V3ldFEUs2n4Ja8Mr5jl9NKkrnuwv7fAnGRYTJiI9ur+dGyb28MbWqFTM33wB21+9r17zL+7eP06K5d916eDphA6eTlKH0WQo7KzwdLAfvjsUj0XbLuLrA1cRf7Og1qFcVwc52rrZo21lUtTWzR5t3Rzg42xrFnuSPdm/Nb4+cBVXMvJxKPYmhnVwv+ecknIVvq0c2np5aFvJK63/N7Yjjl29iV0X0nHmWjb6+FfMLVSrRbyz7SJ+PZUEQQCWPNQNj/WtuWpGTQMTJiI9W/BAJxy6chOXK3eof2Fw3fMZrmbm41ZBKWysZOhmIsMoZFjPDQrAmuPXkKosRmplBclCJsDPxa6iYuRuX5kYOSDQzQEKO/Ou7ClsrfBEv9b44VgiVh1JqDZh2nQ2BWnKYng4yWsdtjOWIE9HTO7ri99PJ+ODndHY8spAiCLw9pYLWP9PMgQB+PSR7nikdyupQyUjYMJEpGeuDnK8PaYj3tp0Hsv2XcHoLp517t+lqS718XOR/F/VZByuDnKsfqYvIpNyEOBqj0B3e7R2sTdqN25je3ZQANacuIbwhFu4cENZZY5VmUqNbw5WrDJ7aUhbk+hDBgBvjmyP7VGpiErOwbaoVByLy8LGszcgE4Clj3XHpJ5MlpqLpvubSSShR/u0Qr8AFxSVqbBw28U6t1nQTPg2pXYCZHgD2rTEy0PbYnQXTwS6OzbpZAmoaAw5vntFT6V/b8q7JSIFKTlFcHWQ4wmJWyHczd3RRtsiYM6Gc9h49gYsZAKWP96TyVIz07R/O4kkIggCPprUFdYWMhyMrZgDURO1WsSpxIoJ36Y4f4lInzQtBnZdSENydiGAivYIX2urS21Mprqk8dygNvBS2EClFmEpE/DVEz3xYHfjNdMk08CEichAAt0dtP8y/d9fl2rscnwlMw/ZBaWwtbJAVx9nI0ZIZHydvJ1wfztXqEXgx8rtUrZFpSIpuxAt7a1NcqWZrbUFPnu0O3r7tcB3U3prNxWm5oUJE5EBvTKsLdq42eNmXgk+qdyM899OVg7H9fFv0eSHZIiAO5vy/vFPMrLyS7TVpRcGt4GdtWlOrb0v0BWbXh6IkZUbUlPzw7+diQxIbmmBjyZ1BQD8eioJZ69n33NOeIJm/hKH46h5GBToik5eTigqU+G5n88gMasALeys8PQAP6lDI6oREyYiAxvQpiUe61MxOXT+5gtVtobg/CVqjgRB0FaZziXnAACev78N7LnNDpkwJkxERjB/TEe42FvjSkY+vj+aoD0ek56HnMIy2FlboKsP+y9R8zGumxe8FTYAACcbS0wNZnWJTBsTJiIjaGFvjXce6AgA+DLsKq7fKgBwV/8lfxdJ9swikoqVhQxvhLQHALwe0p5b7pDJ49/QREYysYcP7m/nipJyNf5vy8Wq26Fw/hI1Q4/19cW5haPw3KAAqUMhqhMTJiIjEQQBH0zsArmlDMfisrA5IkU7f4kNK6m5MvctX6j5YMJEZER+Le0xa0Q7AMD/bb0AZVEZ7Dl/iYjI5DFhIjKyF+5vg/YeDiguq1gt1zfABZacv0REZNL4tzSRkVlbyrD4oa7a55y/RERk+pgwEUmgt58LZo9sjzZu9trNSImIyHQJYl3bqDdzubm5UCgUUCqVcHJykjocIiIiqgd9f3+zwkRERERUByZMRERERHUwm4Tpww8/xMCBA2FnZwdnZ+d6XSOKIhYuXAgvLy/Y2toiJCQEV69eNWygRERE1OSYTcJUWlqKRx99FC+//HK9r/nkk0/w5ZdfYsWKFTh16hTs7e0RGhqK4uJiA0ZKRERETY3ZTfpes2YN3njjDeTk5NR6niiK8Pb2xpw5czB37lwAgFKphIeHB9asWYPHH3+8XvfjpG8iIiLzw0nf9ZSYmIj09HSEhIRojykUCvTv3x/h4eE1XldSUoLc3NwqDyIiImremmzClJ6eDgDw8PCoctzDw0P7WnUWL14MhUKhffj6+ho0TiIiIjJ9kiZM8+bNgyAItT5iYmKMGtP8+fOhVCq1j+TkZKPen4iIiEyPpZQ3nzNnDqZPn17rOW3atGnQe3t6egIAMjIy4OXlpT2ekZGBHj161HidXC6HXC5v0D2JiIioaZI0YXJzc4Obm5tB3jsgIACenp4ICwvTJki5ubk4deqUTivtiIiIiMxmDlNSUhKioqKQlJQElUqFqKgoREVFIT8/X3tOhw4dsGXLFgCAIAh444038MEHH2D79u24cOECpk6dCm9vb0ycOFGin4KIiIjMkaQVJl0sXLgQP//8s/Z5z549AQAHDx7E0KFDAQCxsbFQKpXac9566y0UFBTgxRdfRE5ODgYNGoTdu3fDxsbGqLETERGReTO7PkzGxj5MRERE5od9mIiIiIiMzGyG5KSiKcCxgSUREZH50Hxv62sgjQlTHfLy8gCADSyJiIjMUF5eHhQKRaPfh3OY6qBWq5GamgpHR0cIgiB1OJLIzc2Fr68vkpOTOY/LDPDzMh/8rMwHPyvzovm8Ll++jKCgIMhkjZ+BxApTHWQyGVq1aiV1GCbBycmJf1GYEX5e5oOflfngZ2VefHx89JIsAZz0TURERFQnJkxEREREdWDCRHWSy+VYtGgR99gzE/y8zAc/K/PBz8q8GOLz4qRvIiIiojqwwkRERERUByZMRERERHVgwkRERERUByZMRERERHVgwkQAgG+++Qb+/v6wsbFB//79cfr06RrPXbNmDQRBqPKwsbExYrTN15EjRzB+/Hh4e3tDEARs3bq1zmsOHTqEXr16QS6XIzAwEGvWrDF4nFRB18/r0KFD9/xuCYKA9PR04wTcjC1evBh9+/aFo6Mj3N3dMXHiRMTGxtZ53YYNG9ChQwfY2Niga9eu2LVrlxGibd4a8lnp43uLCRPhjz/+wOzZs7Fo0SJERESge/fuCA0NRWZmZo3XODk5IS0tTfu4fv26ESNuvgoKCtC9e3d888039To/MTER48aNw7BhwxAVFYU33ngDzz//PPbs2WPgSAnQ/fPSiI2NrfL75e7ubqAISePw4cOYOXMmTp48iX379qGsrAyjRo1CQUFBjdecOHECTzzxBJ577jlERkZi4sSJmDhxIi5evGjEyJufhnxWgB6+t0Rq9vr16yfOnDlT+1ylUone3t7i4sWLqz1/9erVokKhMFJ0VBMA4pYtW2o956233hI7d+5c5djkyZPF0NBQA0ZG1anP53Xw4EERgHj79m2jxEQ1y8zMFAGIhw8frvGcxx57TBw3blyVY/379xdnzJhh6PDoLvX5rPTxvcUKUzNXWlqKs2fPIiQkRHtMJpMhJCQE4eHhNV6Xn58PPz8/+Pr6YsKECbh06ZIxwiUdhYeHV/lsASA0NLTWz5ak16NHD3h5eWHkyJE4fvy41OE0S0qlEgDg4uJS4zn8/TIN9fmsgMZ/bzFhauaysrKgUqng4eFR5biHh0eN8yaCgoLw008/Ydu2bVi3bh3UajUGDhyIGzduGCNk0kF6enq1n21ubi6Kiookiopq4uXlhRUrVmDTpk3YtGkTfH19MXToUEREREgdWrOiVqvxxhtv4L777kOXLl1qPK+m3y/OOTOe+n5W+vjestRHwNS8BAcHIzg4WPt84MCB6NixI1auXIn3339fwsiIzFtQUBCCgoK0zwcOHIj4+Hh8/vnn+OWXXySMrHmZOXMmLl68iGPHjkkdCtWhvp+VPr63WGFq5lxdXWFhYYGMjIwqxzMyMuDp6Vmv97CyskLPnj0RFxdniBCpETw9Pav9bJ2cnGBraytRVKSLfv368XfLiF599VXs2LEDBw8eRKtWrWo9t6bfr/r+3UmNo8tn9W8N+d5iwtTMWVtbo3fv3ggLC9MeU6vVCAsLq5KN10alUuHChQvw8vIyVJjUQMHBwVU+WwDYt29fvT9bkl5UVBR/t4xAFEW8+uqr2LJlCw4cOICAgIA6r+HvlzQa8ln9W4O+txo1ZZyahPXr14tyuVxcs2aNePnyZfHFF18UnZ2dxfT0dFEURfHpp58W582bpz3/3XffFffs2SPGx8eLZ8+eFR9//HHRxsZGvHTpklQ/QrORl5cnRkZGipGRkSIAcdmyZWJkZKR4/fp1URRFcd68eeLTTz+tPT8hIUG0s7MT//Of/4jR0dHiN998I1pYWIi7d++W6kdoVnT9vD7//HNx69at4tWrV8ULFy6Ir7/+uiiTycT9+/dL9SM0Gy+//LKoUCjEQ4cOiWlpadpHYWGh9px//114/Phx0dLSUvzss8/E6OhocdGiRaKVlZV44cIFKX6EZqMhn5U+vreYMJEoiqL41Vdfia1btxatra3Ffv36iSdPntS+NmTIEHHatGna52+88Yb2XA8PD3Hs2LFiRESEBFE3P5pl5/9+aD6fadOmiUOGDLnnmh49eojW1tZimzZtxNWrVxs97uZK189ryZIlYtu2bUUbGxvRxcVFHDp0qHjgwAFpgm9mqvucAFT5ffn334WiKIp//vmn2L59e9Ha2lrs3LmzuHPnTuMG3gw15LPSx/eWUHlzIiIiIqoB5zARERER1YEJExEREVEdmDARERER1YEJExEREVEdmDARERER1YEJExEREVEdmDARERER1YEJExEREVEdmDARURWCIGDr1q1Sh2EQpaWlCAwMxIkTJ6QOxSQNGDAAmzZtkjoMIpPEhImoGZg+fToEQYAgCLCysoKHhwdGjhyJn376CWq1usq5aWlpGDNmTL3e19ySqxUrViAgIAADBw6857UZM2bAwsICGzZskCAywN/fH8uXL5fk3hoLFizAvHnz7vl/goiYMBE1G6NHj0ZaWhquXbuGv//+G8OGDcPrr7+OBx54AOXl5drzPD09IZfLJYzUMERRxNdff43nnnvuntcKCwuxfv16vPXWW/jpp58kiK5+VCqVQZOZMWPGIC8vD3///bfB7kFkrpgwETUTcrkcnp6e8PHxQa9evfD2229j27Zt+Pvvv7FmzRrteXdXjUpLS/Hqq6/Cy8sLNjY28PPzw+LFiwFUVEQAYNKkSRAEQfs8Pj4eEyZMgIeHBxwcHNC3b1/s37+/Siz+/v746KOP8Oyzz8LR0RGtW7fGqlWrqpxz48YNPPHEE3BxcYG9vT369OmDU6dOaV/ftm0bevXqBRsbG7Rp0wbvvvtulcTv386ePYv4+HiMGzfuntc2bNiATp06Yd68eThy5AiSk5OrvD59+nRMnDgRn332Gby8vNCyZUvMnDkTZWVl2nPS0tIwbtw42NraIiAgAL/99luVqpEoivjf//6H1q1bQy6Xw9vbG7NmzQIADB06FNevX8ebb76prQQCwJo1a+Ds7Izt27ejU6dOkMvlSEpKwu3btzF16lS0aNECdnZ2GDNmDK5evaqNRXPdjh07EBQUBDs7OzzyyCMoLCzEzz//DH9/f7Ro0QKzZs2CSqXSXmdhYYGxY8di/fr1Nf45EjVXTJiImrHhw4eje/fu2Lx5c7Wvf/nll9i+fTv+/PNPxMbG4tdff9UmRv/88w8AYPXq1UhLS9M+z8/Px9ixYxEWFobIyEiMHj0a48ePR1JSUpX3Xrp0Kfr06YPIyEi88sorePnllxEbG6t9jyFDhiAlJQXbt2/HuXPn8NZbb2mrK0ePHsXUqVPx+uuv4/Lly1i5ciXWrFmDDz/8sMaf9ejRo2jfvj0cHR3vee3HH3/ElClToFAoMGbMmCoJpMbBgwcRHx+PgwcP4ueff8aaNWuqnDd16lSkpqbi0KFD2LRpE1atWoXMzEzt65s2bcLnn3+OlStX4urVq9i6dSu6du0KANi8eTNatWqF9957D2lpaUhLS9NeV1hYiCVLluCHH37ApUuX4O7ujunTp+PMmTPYvn07wsPDIYoixo4dWyWBKywsxJdffon169dj9+7dOHToECZNmoRdu3Zh165d+OWXX7By5Ups3Lixys/Zr18/HD16tMY/R6JmSySiJm/atGnihAkTqn1t8uTJYseOHbXPAYhbtmwRRVEUX3vtNXH48OGiWq2u9tq7z61N586dxa+++kr73M/PT5wyZYr2uVqtFt3d3cXvvvtOFEVRXLlypejo6CjeunWr2vcbMWKE+NFHH1U59ssvv4heXl41xvD666+Lw4cPv+f4lStXRCsrK/HmzZuiKIrili1bxICAgCo/87Rp00Q/Pz+xvLxce+zRRx8VJ0+eLIqiKEZHR4sAxH/++Uf7+tWrV0UA4ueffy6KoiguXbpUbN++vVhaWlptfH5+ftpzNVavXi0CEKOioqrEC0A8fvy49lhWVpZoa2sr/vnnn1Wui4uL054zY8YM0c7OTszLy9MeCw0NFWfMmFHlntu2bRNlMpmoUqmqjZOouWKFiaiZE0VROwT0b9OnT0dUVBSCgoIwa9Ys7N27t873y8/Px9y5c9GxY0c4OzvDwcEB0dHR91SYunXrpv1vQRDg6emprchERUWhZ8+ecHFxqfYe586dw3vvvQcHBwft44UXXkBaWhoKCwurvaaoqAg2Njb3HP/pp58QGhoKV1dXAMDYsWOhVCpx4MCBKud17twZFhYW2udeXl7aeGNjY2FpaYlevXppXw8MDESLFi20zx999FEUFRWhTZs2eOGFF7Bly5ZahxA1rK2tq/xZRUdHw9LSEv3799cea9myJYKCghAdHa09Zmdnh7Zt22qfe3h4wN/fHw4ODlWO3V0FAwBbW1uo1WqUlJTUGRtRc8KEiaiZi46ORkBAQLWv9erVC4mJiXj//fdRVFSExx57DI888kit7zd37lxs2bIFH330EY4ePYqoqCh07doVpaWlVc6zsrKq8lwQBO2Qm62tba33yM/Px7vvvouoqCjt48KFC7h69Wq1SREAuLq64vbt21WOqVQq/Pzzz9i5cycsLS1haWkJOzs7ZGdn3zP5u7Z468PX1xexsbH49ttvYWtri1deeQWDBw+uMoxWHVtb2xoT2tpUF299fobs7GzY29vX+RkQNTeWUgdARNI5cOAALly4gDfffLPGc5ycnDB58mRMnjwZjzzyCEaPHo3s7Gy4uLjAysqqyqRhADh+/DimT5+OSZMmAahIbq5du6ZTXN26dcMPP/ygvc+/9erVC7GxsQgMDKz3e/bs2RPfffddlYrarl27kJeXh8jIyCrVo4sXL+KZZ55BTk4OnJ2d63zvoKAglJeXIzIyEr179wYAxMXF3ZOg2draYvz48Rg/fjxmzpyJDh064MKFC+jVqxesra3v+bOsTseOHVFeXo5Tp05p2yPcunULsbGx6NSpU33/OGp08eJF9OzZs9HvQ9TUsMJE1EyUlJQgPT0dKSkpiIiIwEcffYQJEybggQcewNSpU6u9ZtmyZfj9998RExODK1euYMOGDfD09NQmEf7+/ggLC0N6ero2OWjXrh02b96MqKgonDt3Dk8++aTOS+GfeOIJeHp6YuLEiTh+/DgSEhKwadMmhIeHAwAWLlyItWvX4t1338WlS5cQHR2N9evXY8GCBTW+57Bhw5Cfn49Lly5pj/34448YN24cunfvji5dumgfjz32GJydnfHrr7/WK94OHTogJCQEL774Ik6fPo3IyEi8+OKLVapDa9aswY8//oiLFy8iISEB69atg62tLfz8/LR/lkeOHEFKSgqysrJqvFe7du0wYcIEvPDCCzh27BjOnTuHKVOmwMfHBxMmTKhXvLU5evQoRo0a1ej3IWpqmDARNRO7d++Gl5cX/P39MXr0aBw8eBBffvkltm3bVqW6cjdHR0d88skn6NOnD/r27Ytr165h165dkMkq/upYunQp9u3bB19fX21VYtmyZWjRogUGDhyI8ePHIzQ0tMrcnvqwtrbG3r174e7ujrFjx6Jr1674+OOPtXGGhoZix44d2Lt3L/r27YsBAwbg888/1yYf1WnZsiUmTZqkTYIyMjKwc+dOPPzww/ecK5PJMGnSJPz444/1jnnt2rXw8PDA4MGDMWnSJLzwwgtwdHTUDhE6Ozvj+++/x3333Ydu3bph//79+Ouvv9CyZUsAwHvvvYdr166hbdu2cHNzq/Veq1evRu/evfHAAw8gODgYoihi165d9wy56SolJQUnTpzAM88806j3IWqKBFEURamDICIyhvPnz2PkyJGIj4+vMvnZEG7cuAFfX1/s378fI0aMMOi99OW///0vbt++fU9PLCLiHCYiaka6deuGJUuWIDExUdsDSV8OHDiA/Px8dO3aFWlpaXjrrbfg7++PwYMH6/U+huTu7o7Zs2dLHQaRSWKFiYhID/bs2YM5c+YgISEBjo6OGDhwIJYvX17rMCERmQ8mTERERER14KRvIiIiojowYSIiIiKqAxMmIiIiojowYSIiIiKqAxMmIiIiojowYSIiIiKqAxMmIiIiojowYSIiIiKqw/8DmuDLTyWJXtkAAAAASUVORK5CYII=" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 9 + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "You can see a decreasing function in energy, the atoms start repelling each other at low distances, but it is noisy and there is no clear minimal distance.", + "id": "30c20be68b6169db" }, { "metadata": {}, "cell_type": "markdown", "source": [ - "You can see a decreasing function in energy, the atoms start repelling each other at low distances, but it is noisy and there is no clear minimal distance.\n", + "### Changing optimizer settings\n", "\n", - "Let's try again with more iterations for the optimizer" + "Let's try again with more iterations for the optimizer:" ], "id": "12532766a5255712" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T11:08:52.481152Z", - "start_time": "2024-06-14T11:07:31.137568Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "# optimizer = COBYLA(maxiter=10) # replace in file\n", + "\n", "plot_output()" ], "id": "3cd4588bbfe09334", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 10 + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -468,42 +388,16 @@ "id": "18bf8f2a8edddf32" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T11:16:36.706336Z", - "start_time": "2024-06-14T11:12:08.276160Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "# optimizer = COBYLA(maxiter=100) # replace in file\n", + "\n", "plot_output()" ], "id": "5be01bb287638732", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 11 + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -512,12 +406,7 @@ "id": "1b1cc8d9d57d3a6e" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-14T12:32:41.016517Z", - "start_time": "2024-06-14T12:30:30.481949Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "# from qiskit_algorithms.optimizers import NELDER_MEAD\n", @@ -527,42 +416,22 @@ "plot_output()" ], "id": "7c4ec6665a1799d2", - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 18 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "You can print the circuit that is executed. First we add the circuit to the results, in the file, next we print it with the `print_circuit` function. ", + "source": [ + "### Printing the circuit\n", + "\n", + "You can print the circuit that is executed. First we add the circuit to the results, in the file, next we print it with the `print_circuit` function. " + ], "id": "caa4cf925d934c99" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "from qiskit import transpile\n", "\n", @@ -570,7 +439,9 @@ "result_dict[\"circuit\"] = repr(transpiled_circuit.draw()).replace(\"'\", '\"')\n", "result_dict[\"circuit_depth\"] = transpiled_circuit.depth()\n" ], - "id": "7edac0283f5608f8" + "id": "7edac0283f5608f8", + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -579,12 +450,7 @@ "id": "f6357e31c4ddbb2e" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-17T12:54:21.888291Z", - "start_time": "2024-06-17T12:53:38.432718Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "from json import loads\n", @@ -599,112 +465,21 @@ "print_circuit()" ], "id": "d605454a9ede6840", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "global phase: 3π/2\n", - " ┌─────────┐┌──────────┐┌───┐┌──────────────┐┌───┐┌───┐ ┌───┐ ┌───┐┌───┐»\n", - "q_0: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[0]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", - " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", - "q_1: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", - " ┌──┴───┴──┐┌──────────┐┌───┐┌──────────────┐┌───┐├───┤└┬───┬┘├───┤┌───┐»\n", - "q_2: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[1]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", - " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", - "q_3: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", - " └───┘ └───┘└─────┘└───┘ »\n", - "« ┌───────────────┐┌───┐┌───┐┌─────┐┌───┐ ┌───┐┌────────────────┐»\n", - "«q_0: ┤ Rz(-1.0*t[0]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├┤ Rz(-0.25*t[2]) ├»\n", - "« └───────────────┘└─┬─┘├───┤└┬───┬┘├───┤ ┌───┐└─┬─┘└────────────────┘»\n", - "«q_1: ───────────────────■──┤ H ├─┤ S ├─┤ H ├─────┤ X ├──■────────────────────»\n", - "« ┌───────────────┐┌───┐├───┤┌┴───┴┐├───┤┌───┐└─┬─┘ »\n", - "«q_2: ┤ Rz(-1.0*t[1]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├┤ X ├──■─────────────────────────»\n", - "« └───────────────┘└─┬─┘└───┘└─────┘└───┘└─┬─┘ »\n", - "«q_3: ───────────────────■─────────────────────■──────────────────────────────»\n", - "« »\n", - "« ┌───┐ ┌───┐┌────────────────┐┌───┐»\n", - "«q_0: ┤ X ├─────────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├»\n", - "« └─┬─┘┌───┐┌───┐┌─────┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘»\n", - "«q_1: ──■──┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├──■──────────────────────■──»\n", - "« └─┬─┘├───┤└─────┘└───┘ ┌───┐└─┬─┘ »\n", - "«q_2: ───────■──┤ X ├─────────────────┤ X ├──■──────────────────────────────»\n", - "« └─┬─┘ ┌───┐ ┌───┐┌───┐└─┬─┘ »\n", - "«q_3: ────────────■───┤ H ├─┤ S ├┤ H ├──■───────────────────────────────────»\n", - "« └───┘ └───┘└───┘ »\n", - "« ┌───┐┌────────────────┐┌───┐ »\n", - "«q_0: ───────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├──────────»\n", - "« ┌───┐┌───┐┌───┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐»\n", - "«q_1: ┤ X ├┤ H ├┤ S ├┤ H ├──────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├»\n", - "« └─┬─┘├───┤├───┤├───┤┌───┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", - "«q_2: ──■──┤ X ├┤ H ├┤ S ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├»\n", - "« └─┬─┘└───┘└───┘└───┘└─┬─┘ └─┬─┘»\n", - "«q_3: ───────■───────────────────■──────────────────────────────────────────■──»\n", - "« »\n", - "« ┌───┐┌───────────────┐┌───┐┌───┐┌───┐┌───┐»\n", - "«q_0: ─────────────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├┤ S ├┤ H ├»\n", - "« ┌─────┐ ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤├───┤├───┤»\n", - "«q_1: ┤ Sdg ├─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├»\n", - "« └─────┘ └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤»\n", - "«q_2: ───────────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├»\n", - "« ┌───┐ ┌─────┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", - "«q_3: ─┤ H ├─┤ Sdg ├┤ H ├──■─────────────────────────────────────────■──┤ H ├»\n", - "« └───┘ └─────┘└───┘ └───┘»\n", - "« ┌───┐┌────────────────┐┌───┐ »\n", - "«q_0: ──────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├─────────────────»\n", - "« ┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐┌─────┐»\n", - "«q_1: ─┤ H ├───────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├┤ Sdg ├»\n", - "« ┌┴───┴┐┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘»\n", - "«q_2: ┤ Sdg ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├───────»\n", - "« └┬───┬┘├───┤└─┬─┘ └─┬─┘ ┌───┐ »\n", - "«q_3: ─┤ S ├─┤ H ├──■──────────────────────────────────────────■───┤ H ├─»\n", - "« └───┘ └───┘ └───┘ »\n", - "« ┌───┐┌───────────────┐┌───┐ »\n", - "«q_0: ──────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├────────────────────»\n", - "« ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌───┐┌───┐»\n", - "«q_1: ─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├┤ H ├»\n", - "« └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤├───┤»\n", - "«q_2: ────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├┤ S ├»\n", - "« ┌─────┐┌───┐└─┬─┘ └─┬─┘└───┘└───┘»\n", - "«q_3: ┤ Sdg ├┤ H ├──■─────────────────────────────────────────■────────────»\n", - "« └─────┘└───┘ »\n", - "« ┌───┐┌───────────────┐┌───┐ »\n", - "«q_0: ───────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├───────────────────────────»\n", - "« ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌─────┐┌───┐ »\n", - "«q_1: ──────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ Sdg ├┤ H ├─────»\n", - "« ┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘└───┘ »\n", - "«q_2: ┤ H ├┤ X ├──■───────────────────────────────■──┤ X ├─────────────────»\n", - "« └───┘└─┬─┘ └─┬─┘ ┌───┐ ┌───┐┌───┐»\n", - "«q_3: ───────■─────────────────────────────────────────■───┤ H ├─┤ S ├┤ H ├»\n", - "« └───┘ └───┘└───┘»\n", - "« ┌───┐┌───────────────┐┌───┐┌───┐ \n", - "«q_0: ──────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├──────────\n", - "« ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤┌───┐┌───┐\n", - "«q_1: ─────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├\n", - "« ┌───┐└─┬─┘ └─┬─┘├───┤├───┤\n", - "«q_2: ┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├\n", - "« └─┬─┘ └─┬─┘├───┤\n", - "«q_3: ──■─────────────────────────────────────────■──┤ H ├\n", - "« └───┘\n", - "circuit_depth=92\n" - ] - } - ], - "execution_count": 28 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "We can use a different encoding, e.g. the Jordan-Wigner encoding, instead of the parity encoding.", + "source": [ + "### Changing the qubit encoding\n", + "\n", + "We can use a different encoding, e.g. the Jordan-Wigner encoding, instead of the parity encoding." + ], "id": "ee8f86ac5c47b80b" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-17T12:49:59.010851Z", - "start_time": "2024-06-17T12:49:15.098922Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "# from qiskit_nature.second_q.mappers import JordanWignerMapper\n", @@ -714,114 +489,27 @@ "print_circuit()" ], "id": "5e209f7bd2c9090a", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "global phase: 3π/2\n", - " ┌─────────┐┌──────────┐┌───┐┌──────────────┐┌───┐┌───┐ ┌───┐ ┌───┐┌───┐»\n", - "q_0: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[0]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", - " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", - "q_1: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", - " ┌──┴───┴──┐┌──────────┐┌───┐┌──────────────┐┌───┐├───┤└┬───┬┘├───┤┌───┐»\n", - "q_2: ┤ Rz(π/2) ├┤ Ry(-π/2) ├┤ X ├┤ Rz(1.0*t[1]) ├┤ X ├┤ H ├─┤ S ├─┤ H ├┤ X ├»\n", - " └──┬───┬──┘└──────────┘└─┬─┘└──────────────┘└─┬─┘├───┤┌┴───┴┐├───┤└─┬─┘»\n", - "q_3: ───┤ H ├─────────────────■────────────────────■──┤ H ├┤ Sdg ├┤ H ├──■──»\n", - " └───┘ └───┘└─────┘└───┘ »\n", - "« ┌───────────────┐┌───┐┌───┐┌─────┐┌───┐ ┌───┐┌────────────────┐»\n", - "«q_0: ┤ Rz(-1.0*t[0]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├┤ Rz(-0.25*t[2]) ├»\n", - "« └───────────────┘└─┬─┘├───┤└┬───┬┘├───┤ ┌───┐└─┬─┘└────────────────┘»\n", - "«q_1: ───────────────────■──┤ H ├─┤ S ├─┤ H ├─────┤ X ├──■────────────────────»\n", - "« ┌───────────────┐┌───┐├───┤┌┴───┴┐├───┤┌───┐└─┬─┘ »\n", - "«q_2: ┤ Rz(-1.0*t[1]) ├┤ X ├┤ H ├┤ Sdg ├┤ H ├┤ X ├──■─────────────────────────»\n", - "« └───────────────┘└─┬─┘└───┘└─────┘└───┘└─┬─┘ »\n", - "«q_3: ───────────────────■─────────────────────■──────────────────────────────»\n", - "« »\n", - "« ┌───┐ ┌───┐┌────────────────┐┌───┐»\n", - "«q_0: ┤ X ├─────────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├»\n", - "« └─┬─┘┌───┐┌───┐┌─────┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘»\n", - "«q_1: ──■──┤ X ├┤ H ├┤ Sdg ├┤ H ├──────────┤ X ├──■──────────────────────■──»\n", - "« └─┬─┘├───┤└─────┘└───┘ ┌───┐└─┬─┘ »\n", - "«q_2: ───────■──┤ X ├─────────────────┤ X ├──■──────────────────────────────»\n", - "« └─┬─┘ ┌───┐ ┌───┐┌───┐└─┬─┘ »\n", - "«q_3: ────────────■───┤ H ├─┤ S ├┤ H ├──■───────────────────────────────────»\n", - "« └───┘ └───┘└───┘ »\n", - "« ┌───┐┌────────────────┐┌───┐ »\n", - "«q_0: ───────────────────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├──────────»\n", - "« ┌───┐┌───┐┌───┐┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐»\n", - "«q_1: ┤ X ├┤ H ├┤ S ├┤ H ├──────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├»\n", - "« └─┬─┘├───┤├───┤├───┤┌───┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", - "«q_2: ──■──┤ X ├┤ H ├┤ S ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├»\n", - "« └─┬─┘└───┘└───┘└───┘└─┬─┘ └─┬─┘»\n", - "«q_3: ───────■───────────────────■──────────────────────────────────────────■──»\n", - "« »\n", - "« ┌───┐┌───────────────┐┌───┐┌───┐┌───┐┌───┐»\n", - "«q_0: ─────────────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├┤ S ├┤ H ├»\n", - "« ┌─────┐ ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤├───┤├───┤»\n", - "«q_1: ┤ Sdg ├─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├»\n", - "« └─────┘ └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤»\n", - "«q_2: ───────────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├»\n", - "« ┌───┐ ┌─────┐┌───┐└─┬─┘ └─┬─┘├───┤»\n", - "«q_3: ─┤ H ├─┤ Sdg ├┤ H ├──■─────────────────────────────────────────■──┤ H ├»\n", - "« └───┘ └─────┘└───┘ └───┘»\n", - "« ┌───┐┌────────────────┐┌───┐ »\n", - "«q_0: ──────────────────────┤ X ├┤ Rz(-0.25*t[2]) ├┤ X ├─────────────────»\n", - "« ┌───┐ ┌───┐└─┬─┘└────────────────┘└─┬─┘┌───┐┌───┐┌─────┐»\n", - "«q_1: ─┤ H ├───────────┤ X ├──■──────────────────────■──┤ X ├┤ H ├┤ Sdg ├»\n", - "« ┌┴───┴┐┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘»\n", - "«q_2: ┤ Sdg ├┤ H ├┤ X ├──■────────────────────────────────■──┤ X ├───────»\n", - "« └┬───┬┘├───┤└─┬─┘ └─┬─┘ ┌───┐ »\n", - "«q_3: ─┤ S ├─┤ H ├──■──────────────────────────────────────────■───┤ H ├─»\n", - "« └───┘ └───┘ └───┘ »\n", - "« ┌───┐┌───────────────┐┌───┐ »\n", - "«q_0: ──────────────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├────────────────────»\n", - "« ┌───┐ ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌───┐┌───┐»\n", - "«q_1: ─┤ H ├───────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├┤ H ├»\n", - "« └───┘ ┌───┐└─┬─┘ └─┬─┘├───┤├───┤├───┤»\n", - "«q_2: ────────────┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├┤ S ├»\n", - "« ┌─────┐┌───┐└─┬─┘ └─┬─┘└───┘└───┘»\n", - "«q_3: ┤ Sdg ├┤ H ├──■─────────────────────────────────────────■────────────»\n", - "« └─────┘└───┘ »\n", - "« ┌───┐┌───────────────┐┌───┐ »\n", - "«q_0: ───────────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├───────────────────────────»\n", - "« ┌───┐└─┬─┘└───────────────┘└─┬─┘┌───┐┌───┐┌─────┐┌───┐ »\n", - "«q_1: ──────────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ Sdg ├┤ H ├─────»\n", - "« ┌───┐┌───┐└─┬─┘ └─┬─┘├───┤└─────┘└───┘ »\n", - "«q_2: ┤ H ├┤ X ├──■───────────────────────────────■──┤ X ├─────────────────»\n", - "« └───┘└─┬─┘ └─┬─┘ ┌───┐ ┌───┐┌───┐»\n", - "«q_3: ───────■─────────────────────────────────────────■───┤ H ├─┤ S ├┤ H ├»\n", - "« └───┘ └───┘└───┘»\n", - "« ┌───┐┌───────────────┐┌───┐┌───┐ \n", - "«q_0: ──────────┤ X ├┤ Rz(0.25*t[2]) ├┤ X ├┤ H ├──────────\n", - "« ┌───┐└─┬─┘└───────────────┘└─┬─┘├───┤┌───┐┌───┐\n", - "«q_1: ─────┤ X ├──■─────────────────────■──┤ X ├┤ H ├┤ S ├\n", - "« ┌───┐└─┬─┘ └─┬─┘├───┤├───┤\n", - "«q_2: ┤ X ├──■───────────────────────────────■──┤ X ├┤ H ├\n", - "« └─┬─┘ └─┬─┘├───┤\n", - "«q_3: ──■─────────────────────────────────────────■──┤ H ├\n", - "« └───┘\n" - ] - } - ], - "execution_count": 25 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "markdown", - "source": "Instead of the hydrogen molecule, the VQE algorithm can also be used for different optimization problems. For this, we will replace the `qubit_op` (what we will measure), and the `ansatz` (how we will change the state to be measured). We will measure the operator `X + distance * Z` on one qubit. We have two parameters to optimize, which perform a rotation around the y-axis and then around the z-axis.", + "source": [ + "### Running different optimization problems with VQE\n", + "\n", + "Instead of the hydrogen molecule, the VQE algorithm can also be used for different optimization problems. For this, we will replace the `qubit_op` (what we will measure), and the `ansatz` (how we will change the state to be measured). We will measure the operator `X + distance * Z` on one qubit. We have two parameters to optimize, which perform a rotation around the y-axis and then around the z-axis." + ], "id": "71fece5c28338049" }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "# replace in the file\n", "from qiskit.quantum_info import SparsePauliOp\n", "\n", - "qubit_op = SparsePauliOp([\"X\", \"Z\"], coeffs=np.array([1, distance])) # 3-qubit bitstrings could be [\"XXY\", \"ZYX\"]\n", + "qubit_op = SparsePauliOp([\"X\", \"Z\"], coeffs=np.array([1, distance])) # e.g. 3-qubit bitstrings could be [\"XXY\", \"ZYX\"]\n", "nuclear_repulsion_energy = 0\n", "\n", "from qiskit import QuantumCircuit\n", @@ -836,7 +524,9 @@ "result_dict[\"optimal_t_0\"] = result.optimal_parameters[params[0]]\n", "result_dict[\"optimal_t_1\"] = result.optimal_parameters[params[1]]" ], - "id": "d94d3ecff8fb7e0d" + "id": "d94d3ecff8fb7e0d", + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -845,12 +535,7 @@ "id": "626ab8b8d9863237" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-17T14:26:16.461835Z", - "start_time": "2024-06-17T14:23:41.458300Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "from json import loads\n", @@ -874,29 +559,8 @@ "plot_outputs()" ], "id": "6587e1cab0c242a", - "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 49 + "outputs": [], + "execution_count": null }, { "metadata": {}, diff --git a/examples/hydrogen_qiskit.py b/examples/hydrogen_qiskit.py index 05e51a45..8fca7068 100644 --- a/examples/hydrogen_qiskit.py +++ b/examples/hydrogen_qiskit.py @@ -1,6 +1,6 @@ # (H2) Hydrogen molecule ground state energy determined using VQE with a UCCSD-ansatz function. -# Compared with Hartee-Fock energies and with energies calculated by NumPyMinimumEigensolver # This script is based on the Qiskit Chemistry tutorials +import dataclasses from dataclasses import dataclass from pathlib import Path from typing import Any @@ -9,7 +9,7 @@ import numpy as np from qiskit import transpile from qiskit.primitives import BackendEstimator -from qiskit_algorithms import NumPyMinimumEigensolverResult, VQEResult +from qiskit_algorithms import VQEResult from qiskit_algorithms.minimum_eigensolvers import VQE from qiskit_algorithms.optimizers import COBYLA from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock @@ -24,7 +24,7 @@ @dataclass class _GroundStateEnergyResults: - result: VQEResult | NumPyMinimumEigensolverResult + result: VQEResult nuclear_repulsion_energy: float @@ -44,32 +44,26 @@ def calculate_H0(backend: QuantumInspireBackend, distance: float = 0.735) -> _Gr estimator = BackendEstimator(backend=backend) initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) - optimizer = COBYLA(maxiter=1) + optimizer = COBYLA(maxiter=1) # change to maxiter=100 for decent result algo = VQE(estimator, ansatz, optimizer) result = algo.compute_minimum_eigenvalue(qubit_op) - # print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy:.2f}, eigenvalue={result.eigenvalue:.2f}") + print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy:.2f}, eigenvalue={result.eigenvalue:.2f}") return _GroundStateEnergyResults(result, nuclear_repulsion_energy) def execute(qi: QuantumInterface) -> None: - # distances = np.arange(0.3, 2.5, 0.1) - distances = np.arange(0.3, 0.5, 0.1) + distances = np.arange(0.3, 2.5, 0.1) results = [] for distance in distances: ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) - # result = dataclasses.asdict(ground_state_energy_results) - result = {} - # result["eigenvalue"] = ground_state_energy_results.result.eigenvalue - # result["nuclear_repulsion_energy"] = ground_state_energy_results.nuclear_repulsion_energy + result = dataclasses.asdict(ground_state_energy_results) result["total_energy"] = ground_state_energy_results.nuclear_repulsion_energy + ground_state_energy_results.result.eigenvalue result["distance"] = distance results.append(result) - # print(f"{distance}, {result['total_energy']}") qi.results = {"results": results} - # print(results) def finalize(results: Any) -> dict[str, Any]: @@ -97,7 +91,6 @@ def finalize(results: Any) -> dict[str, Any]: plt.plot(distances, energies, label=y_name) plt.legend() plt.show() - plt.savefig(Path("~/repositories/quantuminspire2/env/test.png").expanduser()) # draw optimal circuit of first distance as text circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) diff --git a/examples/simple_vqe.py b/examples/simple_vqe.py deleted file mode 100644 index a6b9e4ed..00000000 --- a/examples/simple_vqe.py +++ /dev/null @@ -1,121 +0,0 @@ -# (H2) Hydrogen molecule ground state energy determined using VQE with a UCCSD-ansatz function. -# Compared with Hartee-Fock energies and with energies calculated by NumPyMinimumEigensolver -# This script is based on the Qiskit Chemistry tutorials -from dataclasses import dataclass -from pathlib import Path -from typing import Any - -import matplotlib.pyplot as plt -import numpy as np -from qiskit import transpile -from qiskit.primitives import BackendEstimator -from qiskit_algorithms import NumPyMinimumEigensolverResult, VQEResult -from qiskit_algorithms.minimum_eigensolvers import VQE -from qiskit_algorithms.optimizers import COBYLA -from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock -from qiskit_nature.second_q.drivers import PySCFDriver -from qiskit_nature.second_q.mappers import ParityMapper - -from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm -from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend -from quantuminspire.util.api.local_backend import LocalBackend -from quantuminspire.util.api.quantum_interface import QuantumInterface - - -@dataclass -class _GroundStateEnergyResults: - result: VQEResult | NumPyMinimumEigensolverResult - nuclear_repulsion_energy: float - - -def calculate_H0(backend: QuantumInspireBackend, distance: float = 0.735) -> _GroundStateEnergyResults: - molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" - driver = PySCFDriver(molecule) - es_problem = driver.run() - - fermionic_op = es_problem.hamiltonian.second_q_op() - n_particles = es_problem.num_particles - n_spatial_orbitals = es_problem.num_spatial_orbitals - nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy - - mapper = ParityMapper(num_particles=(1, 1)) - qubit_op = mapper.map(fermionic_op) - - from qiskit.quantum_info import Pauli - qubit_op = Pauli("X") - - estimator = BackendEstimator(backend=backend) - initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) - ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) - - from qiskit import QuantumCircuit - from qiskit.circuit import Parameter - params = [Parameter("t_0"), Parameter("t_1")] - - ansatz = QuantumCircuit(1) - ansatz.ry(params[0], qubit=0) - ansatz.rz(params[1], qubit=0) - - optimizer = COBYLA(maxiter=1) - - algo = VQE(estimator, ansatz, optimizer) - result = algo.compute_minimum_eigenvalue(qubit_op) - - breakpoint() - result.optimal_parameters - - # print(f"{distance=}: nuclear_repulsion_energy={nuclear_repulsion_energy:.2f}, eigenvalue={result.eigenvalue:.2f}") - return _GroundStateEnergyResults(result, nuclear_repulsion_energy) - - -def execute(qi: QuantumInterface) -> None: - # distances = np.arange(0.3, 2.5, 0.1) - distances = np.arange(0.3, 0.5, 0.1) - results = [] - for distance in distances: - ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) - # result = dataclasses.asdict(ground_state_energy_results) - result = {} - # result["eigenvalue"] = ground_state_energy_results.result.eigenvalue - # result["nuclear_repulsion_energy"] = ground_state_energy_results.nuclear_repulsion_energy - result["total_energy"] = ground_state_energy_results.nuclear_repulsion_energy + ground_state_energy_results.result.eigenvalue - result["distance"] = distance - results.append(result) - # print(f"{distance}, {result['total_energy']}") - - qi.results = {"results": results} - # print(results) - - -def finalize(results: Any) -> dict[str, Any]: - return results - - -if __name__ == "__main__": - # Run the individual steps for debugging - algorithm = HybridAlgorithm("test", "test") - algorithm.read_file(Path(__file__)) - - # from quantuminspire.util.api.remote_backend import RemoteBackend - # backend = RemoteBackend() - # job_id = backend.run(algorithm, backend_type_id=3, number_of_shots=1024) - # results = backend.get_results(job_id) - - local_backend = LocalBackend() - job_id = local_backend.run(algorithm, 0) - results = local_backend.get_results(job_id)["results"] - print("=== Execute ===\n", results) - - # plot total energy vs distance between atoms - for y_name in ["total_energy"]: - distances, energies = [[result[key] for result in results] for key in ["distance", y_name]] - plt.plot(distances, energies, label=y_name) - plt.legend() - plt.show() - plt.savefig(Path("~/repositories/quantuminspire2/env/test.png").expanduser()) - - # draw optimal circuit of first distance as text - circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) - print(circuit.draw("text")) - - From e8b68a505e86f7b9c280d9bf4a1b3a43dbee908a Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Tue, 18 Jun 2024 14:56:17 +0200 Subject: [PATCH 3/9] removed conversion of keys to hex; added labels to plot vs distance --- examples/hydrogen_qiskit.py | 9 +++++---- quantuminspire/util/api/local_backend.py | 3 +-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/examples/hydrogen_qiskit.py b/examples/hydrogen_qiskit.py index 8fca7068..66c1c9ca 100644 --- a/examples/hydrogen_qiskit.py +++ b/examples/hydrogen_qiskit.py @@ -86,10 +86,11 @@ def finalize(results: Any) -> dict[str, Any]: print("=== Execute ===\n", results) # plot total energy vs distance between atoms - for y_name in ["total_energy"]: - distances, energies = [[result[key] for result in results] for key in ["distance", y_name]] - plt.plot(distances, energies, label=y_name) - plt.legend() + distances, energies = [[result[key] for result in results] for key in ["distance", "total_energy"]] + plt.plot(distances, energies) + plt.xlabel("Distance (Angstrom)") + plt.ylabel("Total energy (a.u.)") + plt.show() # draw optimal circuit of first distance as text diff --git a/quantuminspire/util/api/local_backend.py b/quantuminspire/util/api/local_backend.py index a8715990..eb9b16f9 100644 --- a/quantuminspire/util/api/local_backend.py +++ b/quantuminspire/util/api/local_backend.py @@ -94,10 +94,9 @@ def run_hybrid(self, algorithm: HybridAlgorithm, quantum_interface: QuantumInter def run_quantum(self, circuit: str, number_of_shots: int = 1) -> ExecuteCircuitResult: """Execute provided circuit.""" result = self._qxelarator.execute_string(circuit, iterations=number_of_shots) - # Qiskit requires the keys to be in hex notation # todo: use result.results instead of result.state. qxelerator has a bug where it returns only "00" for # result.results, but result.state contains the correct probability for all multi-qubit states. - results = {hex(int(key, 2)): int(round(number_of_shots * abs(val) ** 2)) for key, val in result.state.items()} + results = {key: int(round(number_of_shots * abs(val) ** 2)) for key, val in result.state.items()} return ExecuteCircuitResult( results=results, shots_done=result.shots_done, From 6d828c537ab6db1b6bb1de5724299d242049c6d3 Mon Sep 17 00:00:00 2001 From: Napoleon Cornejo Date: Thu, 20 Jun 2024 23:09:00 +0200 Subject: [PATCH 4/9] [QI2-995] add functionality to retrieve final_results from remote backend --- quantuminspire/cli/command_list.py | 19 +++++++++ quantuminspire/util/api/remote_backend.py | 19 +++++++++ tests/cli/test_command_list.py | 21 ++++++++++ tests/util/api/test_remote_backend.py | 47 +++++++++++++++++++++++ 4 files changed, 106 insertions(+) diff --git a/quantuminspire/cli/command_list.py b/quantuminspire/cli/command_list.py index a7222f67..b48b51b7 100644 --- a/quantuminspire/cli/command_list.py +++ b/quantuminspire/cli/command_list.py @@ -25,6 +25,8 @@ app.add_typer(files_app, name="files", help="Manage files") results_app = Typer(no_args_is_help=True) app.add_typer(results_app, name="results", help="Manage results") +final_results_app = Typer(no_args_is_help=True) +app.add_typer(final_results_app, name="final_results", help="Manage final results") class Destination(str, Enum): @@ -288,6 +290,23 @@ def get_results(job_id: int = typer.Argument(..., help="The id of the run")) -> typer.echo(results) +@final_results_app.command("get") +def get_final_results(job_id: int = typer.Argument(..., help="The id of the run")) -> None: + """Retrieve the final results for a run. + + Takes the id as returned by upload_files and retrieves the final results for that job, if it's finished. + """ + backend = RemoteBackend() + results = backend.get_final_results(job_id) + + if results is None: + typer.echo("No final results.") + raise typer.Exit(1) + + typer.echo("Raw final results:") + typer.echo(results) + + @app.command("login") def login( host: str = typer.Argument( diff --git a/quantuminspire/util/api/remote_backend.py b/quantuminspire/util/api/remote_backend.py index 6153e03c..f32f8e60 100644 --- a/quantuminspire/util/api/remote_backend.py +++ b/quantuminspire/util/api/remote_backend.py @@ -29,6 +29,8 @@ File, FileIn, FilesApi, + FinalResult, + FinalResultsApi, Job, JobIn, JobsApi, @@ -77,10 +79,22 @@ async def _get_results(self, job_id: int) -> Any: return await self._read_results_for_job(api_client, job) + async def _get_final_results(self, job_id: int) -> Any: + async with ApiClient(self._configuration) as api_client: + job = await self._read_job(api_client, job_id) + if job.status != JobStatus.COMPLETED: + return None + + return await self._read_final_results_for_job(api_client, job) + def get_results(self, job_id: int) -> Any: """Get results for algorithm/circuit.""" return asyncio.run(self._get_results(job_id)) + def get_final_results(self, job_id: int) -> Any: + """Get final results for algorithm/circuit.""" + return asyncio.run(self._get_final_results(job_id)) + async def _create_flow( self, program: BaseAlgorithm, backend_type_id: int, number_of_shots: Optional[int] = None ) -> int: @@ -165,3 +179,8 @@ async def _read_job(api_client: ApiClient, job_id: int) -> Job: async def _read_results_for_job(api_client: ApiClient, job: Job) -> List[Result]: api_instance = ResultsApi(api_client) return await api_instance.read_results_by_job_id_results_job_job_id_get(job.id) # type: ignore + + @staticmethod + async def _read_final_results_for_job(api_client: ApiClient, job: Job) -> List[FinalResult]: + api_instance = FinalResultsApi(api_client) + return await api_instance.read_final_result_by_job_id_final_results_job_job_id_get(job.id) # type: ignore diff --git a/tests/cli/test_command_list.py b/tests/cli/test_command_list.py index 4376b62d..909bebcf 100644 --- a/tests/cli/test_command_list.py +++ b/tests/cli/test_command_list.py @@ -95,6 +95,27 @@ def test_results_get_no_results(mocker: MockerFixture) -> None: mock_remote_backend_inst.get_results.assert_called_once() +def test_final_results_get(mocker: MockerFixture) -> None: + mock_remote_backend_inst = MagicMock() + mocker.patch("quantuminspire.cli.command_list.RemoteBackend", return_value=mock_remote_backend_inst) + + result = runner.invoke(app, ["final_results", "get", "1"]) + + assert result.exit_code == 0 + mock_remote_backend_inst.get_final_results.assert_called_once() + + +def test_final_results_get_no_results(mocker: MockerFixture) -> None: + mock_remote_backend_inst = MagicMock() + mock_remote_backend_inst.get_final_results.return_value = None + mocker.patch("quantuminspire.cli.command_list.RemoteBackend", return_value=mock_remote_backend_inst) + + result = runner.invoke(app, ["final_results", "get", "1"]) + + assert result.exit_code == 1 + mock_remote_backend_inst.get_final_results.assert_called_once() + + def test_login(mocker: MockerFixture, mocked_config_file: MagicMock) -> None: device_session = mocker.patch("quantuminspire.cli.command_list.OauthDeviceSession")() webbrowser_open = mocker.patch("quantuminspire.cli.command_list.webbrowser.open") diff --git a/tests/util/api/test_remote_backend.py b/tests/util/api/test_remote_backend.py index 216381ab..59da319f 100644 --- a/tests/util/api/test_remote_backend.py +++ b/tests/util/api/test_remote_backend.py @@ -37,6 +37,8 @@ def compute_api_client(mocker: MockerFixture) -> None: mocker.patch("quantuminspire.util.api.remote_backend.ShareType", return_value=MagicMock()) mocker.patch("quantuminspire.util.api.remote_backend.Result", return_value=MagicMock()) mocker.patch("quantuminspire.util.api.remote_backend.ResultsApi", return_value=AsyncMock()) + mocker.patch("quantuminspire.util.api.remote_backend.FinalResult", return_value=MagicMock()) + mocker.patch("quantuminspire.util.api.remote_backend.FinalResultsApi", return_value=AsyncMock()) @pytest.fixture @@ -118,3 +120,48 @@ def test_get_results_not_completed( api_client.assert_has_calls([call().__aenter__(), call().__aexit__(None, None, None)]) jobs_api_instance.read_job_jobs_id_get.assert_called_with(job.id) results_api_instance.read_results_by_job_id_results_job_job_id_get.assert_not_called() + + +def test_get_final_results( + mocker: MockerFixture, api_client: MagicMock, mocked_settings: MagicMock, mocked_authentication: MagicMock +) -> None: + backend = RemoteBackend() + jobs_api_instance = AsyncMock() + job = MagicMock() + job.status = JobStatus.COMPLETED + job.id = 1 + jobs_api_instance.read_job_jobs_id_get.return_value = job + + final_results_api_instance = AsyncMock() + results = MagicMock() + final_results_api_instance.read_final_result_by_job_id_final_results_job_job_id_get.return_value = results + + mocker.patch("quantuminspire.util.api.remote_backend.JobsApi", return_value=jobs_api_instance) + mocker.patch("quantuminspire.util.api.remote_backend.FinalResultsApi", return_value=final_results_api_instance) + backend.get_final_results(job.id) + jobs_api_instance.read_job_jobs_id_get.assert_called_with(job.id) + final_results_api_instance.read_final_result_by_job_id_final_results_job_job_id_get.assert_called_with(job.id) + + +def test_get_final_results_not_completed( + mocker: MockerFixture, + api_client: MagicMock, + compute_api_client: None, + mocked_settings: MagicMock, + mocked_authentication: MagicMock, +) -> None: + backend = RemoteBackend() + jobs_api_instance = AsyncMock() + job = MagicMock() + job.id = 1 + job.status = JobStatus.RUNNING + jobs_api_instance.read_job_jobs_id_get.return_value = job + + final_results_api_instance = AsyncMock() + + mocker.patch("quantuminspire.util.api.remote_backend.JobsApi", return_value=jobs_api_instance) + mocker.patch("quantuminspire.util.api.remote_backend.FinalResultsApi", return_value=final_results_api_instance) + backend.get_final_results(job.id) + api_client.assert_has_calls([call().__aenter__(), call().__aexit__(None, None, None)]) + jobs_api_instance.read_job_jobs_id_get.assert_called_with(job.id) + final_results_api_instance.read_final_result_by_job_id_final_results_job_job_id_get.assert_not_called() From 1f8cbf2ba9c61ea1ff00d5d0aedf43fbf35a5439 Mon Sep 17 00:00:00 2001 From: Napoleon Cornejo Date: Thu, 20 Jun 2024 23:11:19 +0200 Subject: [PATCH 5/9] [QI2-995] keep qiskit 1.0.2 pinned --- .github/dependabot.yml | 2 ++ poetry.lock | 30 +++++++++++++++--------------- pyproject.toml | 2 +- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 82afc68d..a85acfde 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -13,6 +13,8 @@ updates: ignore: - dependency-name: "opensquirrel" versions: ["*"] + - dependency-name: "qiskit" + versions: [ "*" ] - dependency-name: "qi-compute-api-client" versions: ["*"] reviewers: diff --git a/poetry.lock b/poetry.lock index 4b9ae9f7..8dbf274f 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. [[package]] name = "aiohttp" @@ -1336,27 +1336,27 @@ resolved_reference = "26857ef229de7e2010e9b0915ef468b66d437598" [[package]] name = "qiskit" -version = "1.1.0" +version = "1.0.2" description = "An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives." optional = false python-versions = ">=3.8" files = [ - {file = "qiskit-1.1.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:1abad8ac96dceb838e279fecae713f26f5debbd85b476e0a52ea829cd823da95"}, - {file = "qiskit-1.1.0-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c2345eaa770a0112a667c6bcbcd9694dc7eed274f1ceea0732ddb6fb42336ccc"}, - {file = "qiskit-1.1.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:3133d90bda74ec487f205c68ba501cb5f27a23a146ff5f3de70eb93084a906b8"}, - {file = "qiskit-1.1.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:135f8dcd4759ea6d5989abb68d494d47d86a8068deaef4addb365e8fd89d87a8"}, - {file = "qiskit-1.1.0-cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:06d7081b8c4fb51cd613822d6365643fb0673cdaf4e0fa40b59602f61d9e1229"}, - {file = "qiskit-1.1.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1b4f0e946d703f2bfb53d97fe7156444e55ad2d3cfb853a84b756c50877dc368"}, - {file = "qiskit-1.1.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8fda2001a3d87c85a3166e660cb8f9f8b2842bd2aa2867e679cc3a8b9ca8785a"}, - {file = "qiskit-1.1.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01da5ebdcf907435d1ab47ea024bb791b4dea8245c148b89bc68e606c45eb478"}, - {file = "qiskit-1.1.0-cp38-abi3-win32.whl", hash = "sha256:3d9cf7fa7d0a17a500b0181eae07c08d38e9a6a67789e09736b2de334159edfe"}, - {file = "qiskit-1.1.0-cp38-abi3-win_amd64.whl", hash = "sha256:26eb1b391ac36e831bec0f7dd3c78b426ea5b0963b124a749b8da38f03c2e875"}, - {file = "qiskit-1.1.0.tar.gz", hash = "sha256:d4d0310029659711dca6b9c0cc593e1b33daf059e52ba221267f85bb47f1bf4e"}, + {file = "qiskit-1.0.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:c78b9488b867f7a121a946db9d453c22e21dab6f00e092defb8010c1a0ec871b"}, + {file = "qiskit-1.0.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:a900f04a0c6349a37aaabbf5a0b1be9fe92c19a6a049e3dcf0aaae0e971d79f2"}, + {file = "qiskit-1.0.2-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:cfe7589d0f61a4a575028cc9d3503fe3965e6cf1df58ace4659d49dc9ce11897"}, + {file = "qiskit-1.0.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4051027bd121efba758db0b48bf6f67ffb74c70bea74fc072c4ccd9fac01a"}, + {file = "qiskit-1.0.2-cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ca533c878b36bfd53a92641cbf552ce4f48821924b107140dfb6e242eeb9425"}, + {file = "qiskit-1.0.2-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:100577d7ee452918e814bcd54f90e3794fdcfdfa32936c1cee2c7fc917485c31"}, + {file = "qiskit-1.0.2-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:186535c0dca89476cbef63420cdb297a8bc73f4444d6c7a49ec9639fb48647c2"}, + {file = "qiskit-1.0.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99f2a8d7ccdc3b7c31ed59e8d83d2da2ca6d2b204d158dd758ad19c9d9c27858"}, + {file = "qiskit-1.0.2-cp38-abi3-win32.whl", hash = "sha256:bf215feeec065398a611b6d6c8bb7b04131b110fbf68ed0967e841d62fb7cb4f"}, + {file = "qiskit-1.0.2-cp38-abi3-win_amd64.whl", hash = "sha256:9f3195eb746f59715837cdbfeaf6b2624f7176248b99faa71add1d9e7ce9fe8f"}, + {file = "qiskit-1.0.2.tar.gz", hash = "sha256:f0480adb1379a5799dde6571d4f717f58909c24100125b6f6addaf123613aee2"}, ] [package.dependencies] dill = ">=0.3" -numpy = ">=1.17,<3" +numpy = ">=1.17,<2" python-dateutil = ">=2.8.0" rustworkx = ">=0.14.0" scipy = ">=1.5" @@ -1917,4 +1917,4 @@ local = ["qxelarator"] [metadata] lock-version = "2.0" python-versions = "^3.9" -content-hash = "c67fde037311253804e67509266bd35bee4539a6a641084902d28e845d08166f" +content-hash = "f84462e1cd01f144cfcd6963ed972de5ff7ff1da49c3a2128155419081bd4634" diff --git a/pyproject.toml b/pyproject.toml index 87483b8c..9680306e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,7 +27,7 @@ pydantic = "^2.7.4" qi-compute-api-client = {git = "https://github.com/QuTech-Delft/compute-api-client.git", rev = "26857ef229de7e2010e9b0915ef468b66d437598"} qxelarator = {version = "^0.7.1", optional = true} pydantic-settings = "^2.3.3" -qiskit = "1.1.0" +qiskit = "1.0.2" oauthlib = "^3.2.2" requests = "^2.32.3" opensquirrel = {git = "https://github.com/QuTech-Delft/OpenSquirrel.git", rev = "82498f268682deac89add8a11b93b27079c46e6d"} From 99c11a63b4af71dea231e6254ee0e6c279e900d5 Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Fri, 21 Jun 2024 10:04:51 +0200 Subject: [PATCH 6/9] working on using platform --- examples/hydrogen_algorithm.py | 78 +++++++++++++++++++++++++++ examples/hydrogen_qiskit.ipynb | 96 ++++++++++++++++++++++++++++++---- 2 files changed, 165 insertions(+), 9 deletions(-) create mode 100644 examples/hydrogen_algorithm.py diff --git a/examples/hydrogen_algorithm.py b/examples/hydrogen_algorithm.py new file mode 100644 index 00000000..8b30b058 --- /dev/null +++ b/examples/hydrogen_algorithm.py @@ -0,0 +1,78 @@ +from typing import Any +from quantuminspire.util.api.quantum_interface import QuantumInterface +import numpy as np + + +def execute(qi: QuantumInterface) -> None: + distances = np.arange(0.3, 0.4, 0.1) + results = [] + for distance in distances: + from qiskit_nature.second_q.drivers import PySCFDriver + + + molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" + driver = PySCFDriver(molecule) + es_problem = driver.run() + + fermionic_op = es_problem.hamiltonian.second_q_op() + n_particles = es_problem.num_particles + n_spatial_orbitals = es_problem.num_spatial_orbitals + nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy + + from qiskit_nature.second_q.mappers import ParityMapper + from qiskit_nature.second_q.mappers import JordanWignerMapper + + mapper = JordanWignerMapper() + qubit_op = mapper.map(fermionic_op) + + from qiskit.quantum_info import SparsePauliOp + + qubit_op = SparsePauliOp(["X", "Z"], coeffs=np.array([1, distance])) + nuclear_repulsion_energy = 0 + + from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD + + initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) + ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) + + from qiskit import QuantumCircuit + from qiskit.circuit import Parameter + params = [Parameter("t_0"), Parameter("t_1")] + + ansatz = QuantumCircuit(1) + ansatz.ry(params[0], qubit=0) + ansatz.rz(params[1], qubit=0) + + from qiskit.primitives import BackendEstimator + from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend + + backend = QuantumInspireBackend(qi) # qi is passed into `execute` + estimator = BackendEstimator(backend=backend) + + from qiskit_algorithms.optimizers import COBYLA + + optimizer = COBYLA(maxiter=1) + + from qiskit_algorithms import VQE + + algo = VQE(estimator, ansatz, optimizer) + result = algo.compute_minimum_eigenvalue(qubit_op) + + result_dict = {"distance": distance, "total_energy": result.eigenvalue + nuclear_repulsion_energy} + + from qiskit import transpile + + transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) + result_dict["circuit"] = repr(transpiled_circuit.draw()).replace("'", '"') + result_dict["circuit_depth"] = transpiled_circuit.depth() + result_dict["optimal_t_0"] = result.optimal_parameters[params[0]] + result_dict["optimal_t_1"] = result.optimal_parameters[params[1]] + + # result_dict["circuit"] = result.optimal_circuit.decompose(reps=20).draw("text") + results.append(result_dict) + + qi.results = {"results": results} + + +def finalize(results: Any) -> dict[str, Any]: + return results diff --git a/examples/hydrogen_qiskit.ipynb b/examples/hydrogen_qiskit.ipynb index 026e143a..4e7c2e86 100644 --- a/examples/hydrogen_qiskit.ipynb +++ b/examples/hydrogen_qiskit.ipynb @@ -16,13 +16,47 @@ ], "id": "e7de03d20a964a8" }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Logging in to the Quantum Inspire platform\n", + "\n", + "We start by logging on to the platform" + ], + "id": "1fe5e30c745fb8c1" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T11:09:18.979769Z", + "start_time": "2024-06-20T11:09:04.309838Z" + } + }, + "cell_type": "code", + "source": "!poetry run qi login https://staging.qi2.quantum-inspire.com", + "id": "5e712470eefc6d6a", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n", + "Please continue logging in by opening: https://auth.qi2.quantum-inspire.com/realms/oidc_staging/device?user_code=FCGI-RNUA in your browser\r\n", + "Using member ID 9\r\n", + "Login successful!\r\n" + ] + } + ], + "execution_count": 1 + }, { "metadata": {}, "cell_type": "markdown", "source": [ "### Setting up the algorithm Python file\n", "\n", - "We start by make a new empty Python file to hold the algorithm." + "We make a new empty Python file to hold the algorithm." ], "id": "66d29b62f486f266" }, @@ -30,7 +64,11 @@ "cell_type": "code", "id": "initial_id", "metadata": { - "collapsed": true + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-06-20T12:00:48.198724Z", + "start_time": "2024-06-20T12:00:47.791250Z" + } }, "source": [ "from pathlib import Path\n", @@ -38,8 +76,16 @@ "filename = str(Path.cwd() / \"hydrogen_algorithm.py\") \n", "!touch {filename}" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n" + ] + } + ], + "execution_count": 6 }, { "metadata": {}, @@ -96,18 +142,50 @@ "id": "bc44c6b00b985cd7" }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:01:07.927079Z", + "start_time": "2024-06-20T12:00:52.924550Z" + } + }, "cell_type": "code", "source": [ + "import time\n", + "\n", + "\n", "def print_output():\n", - " output = !poetry run qi files run {filename}\n", - " print(output)\n", + " # filename = str(Path.cwd() / \"qaoa.py\") \n", + " upload_output = !poetry run qi files upload {filename} 2\n", + " job_id = upload_output[-1].split()[-1]\n", + " print(f\"{upload_output=}\")\n", + " print(f\"{job_id=}\")\n", + " while True:\n", + " output = !poetry run qi results get {job_id}\n", + " print(output)\n", + " results = output[-1]\n", + " print(results)\n", + " if results != \"No results.\":\n", + " break\n", + " time.sleep(1)\n", + " print(results)\n", " \n", "print_output()" ], "id": "4031bb12fe6b4615", - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "upload_output=['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', 'Using member ID 9', 'Upload file with name: /home/haroldmeerwaldt/repositories/quantuminspire2/examples/hydrogen_algorithm.py', 'job_id 1935']\n", + "job_id='1935'\n", + "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', 'Using member ID 9', 'Raw results:', \"[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\"]\n", + "[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\n", + "[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\n" + ] + } + ], + "execution_count": 7 }, { "metadata": {}, From 046e4b55cc44012bb51aab3a3d74e2ddbe00cacc Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Mon, 24 Jun 2024 15:42:48 +0200 Subject: [PATCH 7/9] notebook ready for workshop; added json file for ElectronicStructureProblem input --- examples/hydrogen_algorithm.py | 78 --- examples/hydrogen_qiskit.ipynb | 210 +++--- examples/hydrogen_qiskit.json | 1130 ++++++++++++++++++++++++++++++++ 3 files changed, 1245 insertions(+), 173 deletions(-) delete mode 100644 examples/hydrogen_algorithm.py create mode 100644 examples/hydrogen_qiskit.json diff --git a/examples/hydrogen_algorithm.py b/examples/hydrogen_algorithm.py deleted file mode 100644 index 8b30b058..00000000 --- a/examples/hydrogen_algorithm.py +++ /dev/null @@ -1,78 +0,0 @@ -from typing import Any -from quantuminspire.util.api.quantum_interface import QuantumInterface -import numpy as np - - -def execute(qi: QuantumInterface) -> None: - distances = np.arange(0.3, 0.4, 0.1) - results = [] - for distance in distances: - from qiskit_nature.second_q.drivers import PySCFDriver - - - molecule = f"H 0.0 0.0 0.0; H 0.0 0.0 {distance}" - driver = PySCFDriver(molecule) - es_problem = driver.run() - - fermionic_op = es_problem.hamiltonian.second_q_op() - n_particles = es_problem.num_particles - n_spatial_orbitals = es_problem.num_spatial_orbitals - nuclear_repulsion_energy = es_problem.nuclear_repulsion_energy - - from qiskit_nature.second_q.mappers import ParityMapper - from qiskit_nature.second_q.mappers import JordanWignerMapper - - mapper = JordanWignerMapper() - qubit_op = mapper.map(fermionic_op) - - from qiskit.quantum_info import SparsePauliOp - - qubit_op = SparsePauliOp(["X", "Z"], coeffs=np.array([1, distance])) - nuclear_repulsion_energy = 0 - - from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD - - initial_state = HartreeFock(n_spatial_orbitals, n_particles, mapper) - ansatz = UCCSD(n_spatial_orbitals, n_particles, mapper, initial_state=initial_state) - - from qiskit import QuantumCircuit - from qiskit.circuit import Parameter - params = [Parameter("t_0"), Parameter("t_1")] - - ansatz = QuantumCircuit(1) - ansatz.ry(params[0], qubit=0) - ansatz.rz(params[1], qubit=0) - - from qiskit.primitives import BackendEstimator - from quantuminspire.sdk.qiskit.backend import QuantumInspireBackend - - backend = QuantumInspireBackend(qi) # qi is passed into `execute` - estimator = BackendEstimator(backend=backend) - - from qiskit_algorithms.optimizers import COBYLA - - optimizer = COBYLA(maxiter=1) - - from qiskit_algorithms import VQE - - algo = VQE(estimator, ansatz, optimizer) - result = algo.compute_minimum_eigenvalue(qubit_op) - - result_dict = {"distance": distance, "total_energy": result.eigenvalue + nuclear_repulsion_energy} - - from qiskit import transpile - - transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) - result_dict["circuit"] = repr(transpiled_circuit.draw()).replace("'", '"') - result_dict["circuit_depth"] = transpiled_circuit.depth() - result_dict["optimal_t_0"] = result.optimal_parameters[params[0]] - result_dict["optimal_t_1"] = result.optimal_parameters[params[1]] - - # result_dict["circuit"] = result.optimal_circuit.decompose(reps=20).draw("text") - results.append(result_dict) - - qi.results = {"results": results} - - -def finalize(results: Any) -> dict[str, Any]: - return results diff --git a/examples/hydrogen_qiskit.ipynb b/examples/hydrogen_qiskit.ipynb index 4e7c2e86..83a79693 100644 --- a/examples/hydrogen_qiskit.ipynb +++ b/examples/hydrogen_qiskit.ipynb @@ -3,7 +3,7 @@ { "metadata": {}, "cell_type": "markdown", - "source": "# Hydrogen algorithm for QAL Quantum Inspire hybrid computing workshop ", + "source": "# Hydrogen algorithm for QAL Quantum Inspire Workshop on Hybrid Computing ", "id": "b48c3683d38cabf" }, { @@ -27,28 +27,12 @@ "id": "1fe5e30c745fb8c1" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-20T11:09:18.979769Z", - "start_time": "2024-06-20T11:09:04.309838Z" - } - }, + "metadata": {}, "cell_type": "code", - "source": "!poetry run qi login https://staging.qi2.quantum-inspire.com", + "source": "!poetry run qi login https://api.qi2.quantum-inspire.com", "id": "5e712470eefc6d6a", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n", - "Please continue logging in by opening: https://auth.qi2.quantum-inspire.com/realms/oidc_staging/device?user_code=FCGI-RNUA in your browser\r\n", - "Using member ID 9\r\n", - "Login successful!\r\n" - ] - } - ], - "execution_count": 1 + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -64,11 +48,7 @@ "cell_type": "code", "id": "initial_id", "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2024-06-20T12:00:48.198724Z", - "start_time": "2024-06-20T12:00:47.791250Z" - } + "collapsed": true }, "source": [ "from pathlib import Path\n", @@ -76,16 +56,8 @@ "filename = str(Path.cwd() / \"hydrogen_algorithm.py\") \n", "!touch {filename}" ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\r\n" - ] - } - ], - "execution_count": 6 + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -114,7 +86,7 @@ { "metadata": {}, "cell_type": "markdown", - "source": "Have the `execute` function add something to the results, and have `finalize` return them:", + "source": "Have the `execute` function add something to the results, and have `finalize` return them. The `try ... except` clause gives a return message in case of an exception.", "id": "6614ddb463e43d1c" }, { @@ -123,13 +95,19 @@ "source": [ "from typing import Any\n", "from quantuminspire.util.api.quantum_interface import QuantumInterface\n", + "import traceback\n", "\n", + "global_results = []\n", "\n", "def execute(qi: QuantumInterface) -> None:\n", - " qi.results = {\"results\": 2}\n", + " try:\n", + " result_dict = {\"var\": 2}\n", + " global_results.append(result_dict)\n", + " except Exception:\n", + " global_results.append({\"exception\": traceback.format_exc()})\n", "\n", "def finalize(results: Any) -> dict[str, Any]:\n", - " return results" + " return {\"results\": global_results}" ], "id": "5999967ad19c277d", "outputs": [], @@ -138,54 +116,53 @@ { "metadata": {}, "cell_type": "markdown", - "source": "Use the `print_output` function to execute the Python file and print its output:", + "source": "Use the `print_output` function to execute the Python file and print its output. For debugging, you can change where the execution occurs by setting `Config.run_local = True`.", "id": "bc44c6b00b985cd7" }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-06-20T12:01:07.927079Z", - "start_time": "2024-06-20T12:00:52.924550Z" - } - }, + "metadata": {}, + "cell_type": "code", + "source": [ + "class Config:\n", + " run_local = False" + ], + "id": "3c91d6c0fda3a8a7", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, "cell_type": "code", "source": [ "import time\n", "\n", + "def get_output():\n", + " if Config.run_local:\n", + " output = !poetry run qi files run {filename}\n", + " else:\n", + " upload_output = !poetry run qi files upload {filename} 3\n", + " job_id = upload_output[-1].split()[-1]\n", + " while True:\n", + " results_output = !poetry run qi final_results get {job_id}\n", + " output = results_output[-1]\n", + " if output == \"No final results.\":\n", + " print(\".\", end=\"\")\n", + " else:\n", + " print()\n", + " break\n", + " \n", + " time.sleep(1)\n", + " return output\n", "\n", "def print_output():\n", - " # filename = str(Path.cwd() / \"qaoa.py\") \n", - " upload_output = !poetry run qi files upload {filename} 2\n", - " job_id = upload_output[-1].split()[-1]\n", - " print(f\"{upload_output=}\")\n", - " print(f\"{job_id=}\")\n", - " while True:\n", - " output = !poetry run qi results get {job_id}\n", - " print(output)\n", - " results = output[-1]\n", - " print(results)\n", - " if results != \"No results.\":\n", - " break\n", - " time.sleep(1)\n", - " print(results)\n", + " output = get_output()\n", + " print(output)\n", " \n", "print_output()" ], "id": "4031bb12fe6b4615", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "upload_output=['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', 'Using member ID 9', 'Upload file with name: /home/haroldmeerwaldt/repositories/quantuminspire2/examples/hydrogen_algorithm.py', 'job_id 1935']\n", - "job_id='1935'\n", - "['/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)', 'Using member ID 9', 'Raw results:', \"[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\"]\n", - "[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\n", - "[Result(id=3263, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 335532, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3264, created_on=datetime.datetime(2024, 6, 20, 12, 1, 6, 442220, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3265, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 64513, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1}), Result(id=3266, created_on=datetime.datetime(2024, 6, 20, 12, 1, 7, 172123, tzinfo=TzInfo(UTC)), job_id=1935, metadata_id=1742, number_of_qubits=2, execution_time_in_seconds=0.123, shots_requested=1024, shots_done=4, results={'00000': 1, '00001': 1, '00010': 1, '00011': 1})]\n" - ] - } - ], - "execution_count": 7 + "outputs": [], + "execution_count": null }, { "metadata": {}, @@ -193,9 +170,11 @@ "source": [ "### Adding the hydrogen algorithm\n", "\n", - "In the next couple of cells, we will be adding the hydrogen algorithm to the `execute` function. Add these commands to the function.\n", + "In the next couple of cells, we will be adding the hydrogen algorithm to the `execute` function. Add these commands to the function, inside the `try ... except`\n", + "\n", + "Specify a molecule configuration with the distance between the atoms. Make a molecule driver from this, and use it to generate an ElectronicStructureProblem.\n", "\n", - "Specify a molecule configuration with the distance between the atoms. Make a molecule driver from this, and use it to generate an ElectronicStructureProblem." + "If you want to run the algorithm locally on a Windows computer, see the end of the notebook for instructions." ], "id": "1d27bafa8e78106a" }, @@ -337,7 +316,7 @@ { "metadata": {}, "cell_type": "code", - "source": "qi.results = {\"results\": [{\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}]}", + "source": "result_dict = {\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}", "id": "1748e8c980182c56", "outputs": [], "execution_count": null @@ -364,7 +343,9 @@ "\n", "Now that we can calculate the total energy for a single distance, let's vary the distance and see what happens.\n", "\n", - "Wrap the entire body of the execute function in a for loop to loop over different distances, replacing the constant `distance`." + "Wrap the entire body of the execute function in a for loop to loop over different distances. \n", + "\n", + "Don't forget to replace the constant `distance`." ], "id": "a068b97588e58d8b" }, @@ -375,14 +356,15 @@ "import numpy as np\n", "\n", "def execute(qi: QuantumInterface) -> None:\n", - " distances = np.arange(0.3, 2.5, 0.1)\n", - " results = []\n", - " for distance in distances:\n", - " ... # execute body\n", - " result_dict = {\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}\n", - " results.append(result_dict)\n", - " \n", - " qi.results = {\"results\": results}" + " try:\n", + " distances = np.arange(0.3, 2.5, 0.1)\n", + " results = []\n", + " for distance in distances:\n", + " ... # execute body\n", + " result_dict = {\"distance\": distance, \"total_energy\": result.eigenvalue + nuclear_repulsion_energy}\n", + " global_results.append(result_dict)\n", + " except Exception:\n", + " global_results.append({\"exception\": traceback.format_exc()})" ], "id": "fb84e1461cd3efcb", "outputs": [], @@ -415,9 +397,16 @@ "from json import loads\n", "import matplotlib.pyplot as plt\n", "\n", + "def get_results():\n", + " output = get_output()\n", + " if Config.run_local:\n", + " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " else:\n", + " results = loads(output.split(\"final_result=\")[-1].replace(\"'\", '\"'))[\"results\"]\n", + " return results\n", + "\n", "def plot_output():\n", - " output = !poetry run qi files run {filename}\n", - " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " results = get_results()\n", " distances, energies = [[result[key] for result in results] for key in [\"distance\", \"total_energy\"]]\n", " fig, ax = plt.subplots()\n", " ax.plot(distances, energies)\n", @@ -434,7 +423,7 @@ { "metadata": {}, "cell_type": "markdown", - "source": "You can see a decreasing function in energy, the atoms start repelling each other at low distances, but it is noisy and there is no clear minimal distance.", + "source": "You can see a decreasing function in energy, the atoms start repelling each other at low distances, but the graph is noisy and there is no clear minimal distance.", "id": "30c20be68b6169db" }, { @@ -515,7 +504,7 @@ "\n", "transpiled_circuit = transpile(result.optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's'])\n", "result_dict[\"circuit\"] = repr(transpiled_circuit.draw()).replace(\"'\", '\"')\n", - "result_dict[\"circuit_depth\"] = transpiled_circuit.depth()\n" + "result_dict[\"circuit_depth\"] = transpiled_circuit.depth()" ], "id": "7edac0283f5608f8", "outputs": [], @@ -534,8 +523,7 @@ "from json import loads\n", "\n", "def print_circuit(index: int = 0):\n", - " output = !poetry run qi files run {filename}\n", - " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " results = get_results()\n", " circuits, circuit_depths = [[result[key] for result in results] for key in [\"circuit\", \"circuit_depth\"]]\n", " print(circuits[index])\n", " print(f\"circuit_depth={circuit_depths[index]}\")\n", @@ -622,8 +610,7 @@ "\n", "\n", "def plot_outputs():\n", - " output = !poetry run qi files run {filename}\n", - " results = loads(output[-1].replace(\"'\", '\"'))[\"results\"]\n", + " results = get_results()\n", " keys = [\"distance\", \"total_energy\", \"optimal_t_0\", \"optimal_t_1\"]\n", " distances, energies, optimal_t_0s, optimal_t_1s = [[result[key] for result in results] for key in keys]\n", " fig, ax = plt.subplots()\n", @@ -655,8 +642,41 @@ { "metadata": {}, "cell_type": "markdown", - "source": "", + "source": [ + "### Running the algorithm locally on a Windows computer\n", + "\n", + "The pyscf package is only available on Linux, which the platform has. If you want to run the algorithm locally on Windows, the electronic structure information can be loaded from a pre-made file.\n", + "\n", + "Replace the calculation of `nuclear_repulsion_energy`, `n_particles`, `n_spatial_orbitals`, and `fermionic_op` with the following lines." + ], "id": "99edb42031a2154e" + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "from pathlib import Path\n", + "from json import loads\n", + "from qiskit_nature.second_q.operators import FermionicOp\n", + "\n", + "es_problem_data = loads((Path.cwd() / \"hydrogen_qiskit.json\").read_text())\n", + "idx = min(enumerate(es_problem_data), key=lambda x: abs(x[1][\"distance\"] - distance))[0]\n", + "val_at_distance = es_problem_data[idx]\n", + "\n", + "fermionic_op = FermionicOp(val_at_distance[\"fermionic_op\"])\n", + "n_particles = val_at_distance[\"n_particles\"]\n", + "n_spatial_orbitals = val_at_distance[\"n_spatial_orbitals\"]\n", + "nuclear_repulsion_energy = val_at_distance[\"nuclear_repulsion_energy\"]" + ], + "id": "ad03ad59e6da52e1", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "19d378513f52fd5d" } ], "metadata": { diff --git a/examples/hydrogen_qiskit.json b/examples/hydrogen_qiskit.json new file mode 100644 index 00000000..4545e2ae --- /dev/null +++ b/examples/hydrogen_qiskit.json @@ -0,0 +1,1130 @@ +[ + { + "distance": 0.735, + "nuclear_repulsion_energy": 0.7199689944489797, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.25633907300325, + "+_1 -_1": -0.47189600728114184, + "+_2 -_2": -1.25633907300325, + "+_3 -_3": -0.47189600728114184, + "+_0 +_0 -_0 -_0": 0.33785507740175813, + "+_0 +_1 -_1 -_0": 0.33229086512764816, + "+_0 +_2 -_2 -_0": 0.33785507740175813, + "+_0 +_3 -_3 -_0": 0.33229086512764816, + "+_0 +_0 -_1 -_1": 0.0904655998921157, + "+_0 +_1 -_0 -_1": 0.0904655998921157, + "+_0 +_2 -_3 -_1": 0.0904655998921157, + "+_0 +_3 -_2 -_1": 0.0904655998921157, + "+_1 +_0 -_1 -_0": 0.0904655998921157, + "+_1 +_1 -_0 -_0": 0.0904655998921157, + "+_1 +_2 -_3 -_0": 0.0904655998921157, + "+_1 +_3 -_2 -_0": 0.0904655998921157, + "+_1 +_0 -_0 -_1": 0.33229086512764816, + "+_1 +_1 -_1 -_1": 0.34928686136600906, + "+_1 +_2 -_2 -_1": 0.33229086512764816, + "+_1 +_3 -_3 -_1": 0.34928686136600906, + "+_2 +_0 -_0 -_2": 0.33785507740175813, + "+_2 +_1 -_1 -_2": 0.33229086512764816, + "+_2 +_2 -_2 -_2": 0.33785507740175813, + "+_2 +_3 -_3 -_2": 0.33229086512764816, + "+_2 +_0 -_1 -_3": 0.0904655998921157, + "+_2 +_1 -_0 -_3": 0.0904655998921157, + "+_2 +_2 -_3 -_3": 0.0904655998921157, + "+_2 +_3 -_2 -_3": 0.0904655998921157, + "+_3 +_0 -_1 -_2": 0.0904655998921157, + "+_3 +_1 -_0 -_2": 0.0904655998921157, + "+_3 +_2 -_3 -_2": 0.0904655998921157, + "+_3 +_3 -_2 -_2": 0.0904655998921157, + "+_3 +_0 -_0 -_3": 0.33229086512764816, + "+_3 +_1 -_1 -_3": 0.34928686136600906, + "+_3 +_2 -_2 -_3": 0.33229086512764816, + "+_3 +_3 -_3 -_3": 0.34928686136600906 + } + }, + { + "distance": 0.3, + "nuclear_repulsion_energy": 1.7639240364000002, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.5548851754561257, + "+_1 -_1": 0.04595317511763358, + "+_2 -_2": -1.5548851754561257, + "+_3 -_3": 0.04595317511763358, + "+_0 +_0 -_0 -_0": 0.37600927798826184, + "+_0 +_1 -_1 -_0": 0.37095103552040104, + "+_0 +_2 -_2 -_0": 0.37600927798826184, + "+_0 +_3 -_3 -_0": 0.37095103552040104, + "+_0 +_0 -_1 -_1": 0.08040925960196477, + "+_0 +_1 -_0 -_1": 0.08040925960196477, + "+_0 +_2 -_3 -_1": 0.08040925960196477, + "+_0 +_3 -_2 -_1": 0.08040925960196477, + "+_1 +_0 -_1 -_0": 0.08040925960196477, + "+_1 +_1 -_0 -_0": 0.08040925960196477, + "+_1 +_2 -_3 -_0": 0.08040925960196477, + "+_1 +_3 -_2 -_0": 0.08040925960196477, + "+_1 +_0 -_0 -_1": 0.37095103552040104, + "+_1 +_1 -_1 -_1": 0.3924687472324241, + "+_1 +_2 -_2 -_1": 0.37095103552040104, + "+_1 +_3 -_3 -_1": 0.3924687472324241, + "+_2 +_0 -_0 -_2": 0.37600927798826184, + "+_2 +_1 -_1 -_2": 0.37095103552040104, + "+_2 +_2 -_2 -_2": 0.37600927798826184, + "+_2 +_3 -_3 -_2": 0.37095103552040104, + "+_2 +_0 -_1 -_3": 0.08040925960196477, + "+_2 +_1 -_0 -_3": 0.08040925960196477, + "+_2 +_2 -_3 -_3": 0.08040925960196477, + "+_2 +_3 -_2 -_3": 0.08040925960196477, + "+_3 +_0 -_1 -_2": 0.08040925960196477, + "+_3 +_1 -_0 -_2": 0.08040925960196477, + "+_3 +_2 -_3 -_2": 0.08040925960196477, + "+_3 +_3 -_2 -_2": 0.08040925960196477, + "+_3 +_0 -_0 -_3": 0.37095103552040104, + "+_3 +_1 -_1 -_3": 0.3924687472324241, + "+_3 +_2 -_2 -_3": 0.37095103552040104, + "+_3 +_3 -_3 -_3": 0.3924687472324241 + } + }, + { + "distance": 0.4, + "nuclear_repulsion_energy": 1.3229430273, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.4820918871789468, + "+_1 -_1": -0.1187350500960437, + "+_2 -_2": -1.4820918871789468, + "+_3 -_3": -0.1187350500960437, + "+_0 +_0 -_0 -_0": 0.3684396764471769, + "+_0 +_1 -_1 -_0": 0.3626667181343221, + "+_0 +_2 -_2 -_0": 0.3684396764471769, + "+_0 +_3 -_3 -_0": 0.3626667181343221, + "+_0 +_0 -_1 -_1": 0.08225771201128307, + "+_0 +_1 -_0 -_1": 0.08225771201128307, + "+_0 +_2 -_3 -_1": 0.08225771201128307, + "+_0 +_3 -_2 -_1": 0.08225771201128307, + "+_1 +_0 -_1 -_0": 0.08225771201128307, + "+_1 +_1 -_0 -_0": 0.08225771201128307, + "+_1 +_2 -_3 -_0": 0.08225771201128307, + "+_1 +_3 -_2 -_0": 0.08225771201128307, + "+_1 +_0 -_0 -_1": 0.3626667181343221, + "+_1 +_1 -_1 -_1": 0.3827216984932617, + "+_1 +_2 -_2 -_1": 0.3626667181343221, + "+_1 +_3 -_3 -_1": 0.3827216984932617, + "+_2 +_0 -_0 -_2": 0.3684396764471769, + "+_2 +_1 -_1 -_2": 0.3626667181343221, + "+_2 +_2 -_2 -_2": 0.3684396764471769, + "+_2 +_3 -_3 -_2": 0.3626667181343221, + "+_2 +_0 -_1 -_3": 0.08225771201128307, + "+_2 +_1 -_0 -_3": 0.08225771201128307, + "+_2 +_2 -_3 -_3": 0.08225771201128307, + "+_2 +_3 -_2 -_3": 0.08225771201128307, + "+_3 +_0 -_1 -_2": 0.08225771201128307, + "+_3 +_1 -_0 -_2": 0.08225771201128307, + "+_3 +_2 -_3 -_2": 0.08225771201128307, + "+_3 +_3 -_2 -_2": 0.08225771201128307, + "+_3 +_0 -_0 -_3": 0.3626667181343221, + "+_3 +_1 -_1 -_3": 0.3827216984932617, + "+_3 +_2 -_2 -_3": 0.3626667181343221, + "+_3 +_3 -_3 -_3": 0.3827216984932617 + } + }, + { + "distance": 0.5, + "nuclear_repulsion_energy": 1.05835442184, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.4105283677181675, + "+_1 -_1": -0.25693578239703213, + "+_2 -_2": -1.4105283677181675, + "+_3 -_3": -0.25693578239703213, + "+_0 +_0 -_0 -_0": 0.3598530195281196, + "+_0 +_1 -_1 -_0": 0.35361992077224436, + "+_0 +_2 -_2 -_0": 0.3598530195281196, + "+_0 +_3 -_3 -_0": 0.35361992077224436, + "+_0 +_0 -_1 -_1": 0.08443511384486775, + "+_0 +_1 -_0 -_1": 0.08443511384486775, + "+_0 +_2 -_3 -_1": 0.08443511384486775, + "+_0 +_3 -_2 -_1": 0.08443511384486775, + "+_1 +_0 -_1 -_0": 0.08443511384486775, + "+_1 +_1 -_0 -_0": 0.08443511384486775, + "+_1 +_2 -_3 -_0": 0.08443511384486775, + "+_1 +_3 -_2 -_0": 0.08443511384486775, + "+_1 +_0 -_0 -_1": 0.35361992077224436, + "+_1 +_1 -_1 -_1": 0.3724196851849425, + "+_1 +_2 -_2 -_1": 0.35361992077224436, + "+_1 +_3 -_3 -_1": 0.3724196851849425, + "+_2 +_0 -_0 -_2": 0.3598530195281196, + "+_2 +_1 -_1 -_2": 0.35361992077224436, + "+_2 +_2 -_2 -_2": 0.3598530195281196, + "+_2 +_3 -_3 -_2": 0.35361992077224436, + "+_2 +_0 -_1 -_3": 0.08443511384486775, + "+_2 +_1 -_0 -_3": 0.08443511384486775, + "+_2 +_2 -_3 -_3": 0.08443511384486775, + "+_2 +_3 -_2 -_3": 0.08443511384486775, + "+_3 +_0 -_1 -_2": 0.08443511384486775, + "+_3 +_1 -_0 -_2": 0.08443511384486775, + "+_3 +_2 -_3 -_2": 0.08443511384486775, + "+_3 +_3 -_2 -_2": 0.08443511384486775, + "+_3 +_0 -_0 -_3": 0.35361992077224436, + "+_3 +_1 -_1 -_3": 0.3724196851849425, + "+_3 +_2 -_2 -_3": 0.35361992077224436, + "+_3 +_3 -_3 -_3": 0.3724196851849425 + } + }, + { + "distance": 0.6000000000000001, + "nuclear_repulsion_energy": 0.8819620182, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.3422139948091043, + "+_1 -_1": -0.36577056930683044, + "+_2 -_2": -1.3422139948091043, + "+_3 -_3": -0.36577056930683044, + "+_0 +_0 -_0 -_0": 0.3506688645752537, + "+_0 +_1 -_1 -_0": 0.3443965487030891, + "+_0 +_2 -_2 -_0": 0.3506688645752537, + "+_0 +_3 -_3 -_0": 0.3443965487030891, + "+_0 +_0 -_1 -_1": 0.08686532187282948, + "+_0 +_1 -_0 -_1": 0.08686532187282948, + "+_0 +_2 -_3 -_1": 0.08686532187282948, + "+_0 +_3 -_2 -_1": 0.08686532187282948, + "+_1 +_0 -_1 -_0": 0.08686532187282948, + "+_1 +_1 -_0 -_0": 0.08686532187282948, + "+_1 +_2 -_3 -_0": 0.08686532187282948, + "+_1 +_3 -_2 -_0": 0.08686532187282948, + "+_1 +_0 -_0 -_1": 0.3443965487030891, + "+_1 +_1 -_1 -_1": 0.36225301224570977, + "+_1 +_2 -_2 -_1": 0.3443965487030891, + "+_1 +_3 -_3 -_1": 0.36225301224570977, + "+_2 +_0 -_0 -_2": 0.3506688645752537, + "+_2 +_1 -_1 -_2": 0.3443965487030891, + "+_2 +_2 -_2 -_2": 0.3506688645752537, + "+_2 +_3 -_3 -_2": 0.3443965487030891, + "+_2 +_0 -_1 -_3": 0.08686532187282948, + "+_2 +_1 -_0 -_3": 0.08686532187282948, + "+_2 +_2 -_3 -_3": 0.08686532187282948, + "+_2 +_3 -_2 -_3": 0.08686532187282948, + "+_3 +_0 -_1 -_2": 0.08686532187282948, + "+_3 +_1 -_0 -_2": 0.08686532187282948, + "+_3 +_2 -_3 -_2": 0.08686532187282948, + "+_3 +_3 -_2 -_2": 0.08686532187282948, + "+_3 +_0 -_0 -_3": 0.3443965487030891, + "+_3 +_1 -_1 -_3": 0.36225301224570977, + "+_3 +_2 -_2 -_3": 0.3443965487030891, + "+_3 +_3 -_3 -_3": 0.36225301224570977 + } + }, + { + "distance": 0.7000000000000002, + "nuclear_repulsion_energy": 0.7559674441714285, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.2778530061568751, + "+_1 -_1": -0.44829969610163806, + "+_2 -_2": -1.2778530061568751, + "+_3 -_3": -0.44829969610163806, + "+_0 +_0 -_0 -_0": 0.3411947665760211, + "+_0 +_1 -_1 -_0": 0.3353663891543791, + "+_0 +_2 -_2 -_0": 0.3411947665760211, + "+_0 +_3 -_3 -_0": 0.3353663891543791, + "+_0 +_0 -_1 -_1": 0.08950028803070328, + "+_0 +_1 -_0 -_1": 0.08950028803070328, + "+_0 +_2 -_3 -_1": 0.08950028803070328, + "+_0 +_3 -_2 -_1": 0.08950028803070328, + "+_1 +_0 -_1 -_0": 0.08950028803070328, + "+_1 +_1 -_0 -_0": 0.08950028803070328, + "+_1 +_2 -_3 -_0": 0.08950028803070328, + "+_1 +_3 -_2 -_0": 0.08950028803070328, + "+_1 +_0 -_0 -_1": 0.3353663891543791, + "+_1 +_1 -_1 -_1": 0.3525528160863906, + "+_1 +_2 -_2 -_1": 0.3353663891543791, + "+_1 +_3 -_3 -_1": 0.3525528160863906, + "+_2 +_0 -_0 -_2": 0.3411947665760211, + "+_2 +_1 -_1 -_2": 0.3353663891543791, + "+_2 +_2 -_2 -_2": 0.3411947665760211, + "+_2 +_3 -_3 -_2": 0.3353663891543791, + "+_2 +_0 -_1 -_3": 0.08950028803070328, + "+_2 +_1 -_0 -_3": 0.08950028803070328, + "+_2 +_2 -_3 -_3": 0.08950028803070328, + "+_2 +_3 -_2 -_3": 0.08950028803070328, + "+_3 +_0 -_1 -_2": 0.08950028803070328, + "+_3 +_1 -_0 -_2": 0.08950028803070328, + "+_3 +_2 -_3 -_2": 0.08950028803070328, + "+_3 +_3 -_2 -_2": 0.08950028803070328, + "+_3 +_0 -_0 -_3": 0.3353663891543791, + "+_3 +_1 -_1 -_3": 0.3525528160863906, + "+_3 +_2 -_2 -_3": 0.3353663891543791, + "+_3 +_3 -_3 -_3": 0.3525528160863906 + } + }, + { + "distance": 0.8000000000000003, + "nuclear_repulsion_energy": 0.6614715136499999, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.217826029995106, + "+_1 -_1": -0.5096378744364828, + "+_2 -_2": -1.217826029995106, + "+_3 -_3": -0.5096378744364828, + "+_0 +_0 -_0 -_0": 0.3316650744318082, + "+_0 +_1 -_1 -_0": 0.32672068618194766, + "+_0 +_2 -_2 -_0": 0.3316650744318082, + "+_0 +_3 -_3 -_0": 0.32672068618194766, + "+_0 +_0 -_1 -_1": 0.09231339177803065, + "+_0 +_1 -_0 -_1": 0.09231339177803065, + "+_0 +_2 -_3 -_1": 0.09231339177803065, + "+_0 +_3 -_2 -_1": 0.09231339177803065, + "+_1 +_0 -_1 -_0": 0.09231339177803065, + "+_1 +_1 -_0 -_0": 0.09231339177803065, + "+_1 +_2 -_3 -_0": 0.09231339177803065, + "+_1 +_3 -_2 -_0": 0.09231339177803065, + "+_1 +_0 -_0 -_1": 0.32672068618194766, + "+_1 +_1 -_1 -_1": 0.34339576784573467, + "+_1 +_2 -_2 -_1": 0.32672068618194766, + "+_1 +_3 -_3 -_1": 0.34339576784573467, + "+_2 +_0 -_0 -_2": 0.3316650744318082, + "+_2 +_1 -_1 -_2": 0.32672068618194766, + "+_2 +_2 -_2 -_2": 0.3316650744318082, + "+_2 +_3 -_3 -_2": 0.32672068618194766, + "+_2 +_0 -_1 -_3": 0.09231339177803065, + "+_2 +_1 -_0 -_3": 0.09231339177803065, + "+_2 +_2 -_3 -_3": 0.09231339177803065, + "+_2 +_3 -_2 -_3": 0.09231339177803065, + "+_3 +_0 -_1 -_2": 0.09231339177803065, + "+_3 +_1 -_0 -_2": 0.09231339177803065, + "+_3 +_2 -_3 -_2": 0.09231339177803065, + "+_3 +_3 -_2 -_2": 0.09231339177803065, + "+_3 +_0 -_0 -_3": 0.32672068618194766, + "+_3 +_1 -_1 -_3": 0.34339576784573467, + "+_3 +_2 -_2 -_3": 0.32672068618194766, + "+_3 +_3 -_3 -_3": 0.34339576784573467 + } + }, + { + "distance": 0.9000000000000001, + "nuclear_repulsion_energy": 0.5879746788, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.162220687473326, + "+_1 -_1": -0.555112319820134, + "+_2 -_2": -1.162220687473326, + "+_3 -_3": -0.555112319820134, + "+_0 +_0 -_0 -_0": 0.3222763275632975, + "+_0 +_1 -_1 -_0": 0.3185403149475153, + "+_0 +_2 -_2 -_0": 0.3222763275632975, + "+_0 +_3 -_3 -_0": 0.3185403149475153, + "+_0 +_0 -_1 -_1": 0.09528584687963246, + "+_0 +_1 -_0 -_1": 0.09528584687963246, + "+_0 +_2 -_3 -_1": 0.09528584687963246, + "+_0 +_3 -_2 -_1": 0.09528584687963246, + "+_1 +_0 -_1 -_0": 0.09528584687963246, + "+_1 +_1 -_0 -_0": 0.09528584687963246, + "+_1 +_2 -_3 -_0": 0.09528584687963246, + "+_1 +_3 -_2 -_0": 0.09528584687963246, + "+_1 +_0 -_0 -_1": 0.3185403149475153, + "+_1 +_1 -_1 -_1": 0.33474251896608187, + "+_1 +_2 -_2 -_1": 0.3185403149475153, + "+_1 +_3 -_3 -_1": 0.33474251896608187, + "+_2 +_0 -_0 -_2": 0.3222763275632975, + "+_2 +_1 -_1 -_2": 0.3185403149475153, + "+_2 +_2 -_2 -_2": 0.3222763275632975, + "+_2 +_3 -_3 -_2": 0.3185403149475153, + "+_2 +_0 -_1 -_3": 0.09528584687963246, + "+_2 +_1 -_0 -_3": 0.09528584687963246, + "+_2 +_2 -_3 -_3": 0.09528584687963246, + "+_2 +_3 -_2 -_3": 0.09528584687963246, + "+_3 +_0 -_1 -_2": 0.09528584687963246, + "+_3 +_1 -_0 -_2": 0.09528584687963246, + "+_3 +_2 -_3 -_2": 0.09528584687963246, + "+_3 +_3 -_2 -_2": 0.09528584687963246, + "+_3 +_0 -_0 -_3": 0.3185403149475153, + "+_3 +_1 -_1 -_3": 0.33474251896608187, + "+_3 +_2 -_2 -_3": 0.3185403149475153, + "+_3 +_3 -_3 -_3": 0.33474251896608187 + } + }, + { + "distance": 1.0000000000000002, + "nuclear_repulsion_energy": 0.5291772109199999, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.1108441798837272, + "+_1 -_1": -0.5891210037060832, + "+_2 -_2": -1.1108441798837272, + "+_3 -_3": -0.5891210037060832, + "+_0 +_0 -_0 -_0": 0.31320124976475894, + "+_0 +_1 -_1 -_0": 0.3108533815598568, + "+_0 +_2 -_2 -_0": 0.31320124976475894, + "+_0 +_3 -_3 -_0": 0.3108533815598568, + "+_0 +_0 -_1 -_1": 0.09839529174273515, + "+_0 +_1 -_0 -_1": 0.09839529174273515, + "+_0 +_2 -_3 -_1": 0.09839529174273515, + "+_0 +_3 -_2 -_1": 0.09839529174273515, + "+_1 +_0 -_1 -_0": 0.09839529174273515, + "+_1 +_1 -_0 -_0": 0.09839529174273515, + "+_1 +_2 -_3 -_0": 0.09839529174273515, + "+_1 +_3 -_2 -_0": 0.09839529174273515, + "+_1 +_0 -_0 -_1": 0.3108533815598568, + "+_1 +_1 -_1 -_1": 0.3265353734712872, + "+_1 +_2 -_2 -_1": 0.3108533815598568, + "+_1 +_3 -_3 -_1": 0.3265353734712872, + "+_2 +_0 -_0 -_2": 0.31320124976475894, + "+_2 +_1 -_1 -_2": 0.3108533815598568, + "+_2 +_2 -_2 -_2": 0.31320124976475894, + "+_2 +_3 -_3 -_2": 0.3108533815598568, + "+_2 +_0 -_1 -_3": 0.09839529174273515, + "+_2 +_1 -_0 -_3": 0.09839529174273515, + "+_2 +_2 -_3 -_3": 0.09839529174273515, + "+_2 +_3 -_2 -_3": 0.09839529174273515, + "+_3 +_0 -_1 -_2": 0.09839529174273515, + "+_3 +_1 -_0 -_2": 0.09839529174273515, + "+_3 +_2 -_3 -_2": 0.09839529174273515, + "+_3 +_3 -_2 -_2": 0.09839529174273515, + "+_3 +_0 -_0 -_3": 0.3108533815598568, + "+_3 +_1 -_1 -_3": 0.3265353734712872, + "+_3 +_2 -_2 -_3": 0.3108533815598568, + "+_3 +_3 -_3 -_3": 0.3265353734712872 + } + }, + { + "distance": 1.1000000000000003, + "nuclear_repulsion_energy": 0.4810701917454544, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.0633903726559355, + "+_1 -_1": -0.6147527176739522, + "+_2 -_2": -1.0633903726559355, + "+_3 -_3": -0.6147527176739522, + "+_0 +_0 -_0 -_0": 0.3045858392686184, + "+_0 +_1 -_1 -_0": 0.30366771385989244, + "+_0 +_2 -_2 -_0": 0.3045858392686184, + "+_0 +_3 -_3 -_0": 0.30366771385989244, + "+_0 +_0 -_1 -_1": 0.10161111331032477, + "+_0 +_1 -_0 -_1": 0.10161111331032477, + "+_0 +_2 -_3 -_1": 0.10161111331032477, + "+_0 +_3 -_2 -_1": 0.10161111331032477, + "+_1 +_0 -_1 -_0": 0.10161111331032477, + "+_1 +_1 -_0 -_0": 0.10161111331032477, + "+_1 +_2 -_3 -_0": 0.10161111331032477, + "+_1 +_3 -_2 -_0": 0.10161111331032477, + "+_1 +_0 -_0 -_1": 0.30366771385989244, + "+_1 +_1 -_1 -_1": 0.3187399385770175, + "+_1 +_2 -_2 -_1": 0.30366771385989244, + "+_1 +_3 -_3 -_1": 0.3187399385770175, + "+_2 +_0 -_0 -_2": 0.3045858392686184, + "+_2 +_1 -_1 -_2": 0.30366771385989244, + "+_2 +_2 -_2 -_2": 0.3045858392686184, + "+_2 +_3 -_3 -_2": 0.30366771385989244, + "+_2 +_0 -_1 -_3": 0.10161111331032477, + "+_2 +_1 -_0 -_3": 0.10161111331032477, + "+_2 +_2 -_3 -_3": 0.10161111331032477, + "+_2 +_3 -_2 -_3": 0.10161111331032477, + "+_3 +_0 -_1 -_2": 0.10161111331032477, + "+_3 +_1 -_0 -_2": 0.10161111331032477, + "+_3 +_2 -_3 -_2": 0.10161111331032477, + "+_3 +_3 -_2 -_2": 0.10161111331032477, + "+_3 +_0 -_0 -_3": 0.30366771385989244, + "+_3 +_1 -_1 -_3": 0.3187399385770175, + "+_3 +_2 -_2 -_3": 0.30366771385989244, + "+_3 +_3 -_3 -_3": 0.3187399385770175 + } + }, + { + "distance": 1.2000000000000004, + "nuclear_repulsion_energy": 0.4409810090999999, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -1.0195850735403222, + "+_1 -_1": -0.6340139768872511, + "+_2 -_2": -1.0195850735403222, + "+_3 -_3": -0.6340139768872511, + "+_0 +_0 -_0 -_0": 0.2965412157060776, + "+_0 +_1 -_1 -_0": 0.2969830817196037, + "+_0 +_2 -_2 -_0": 0.2965412157060776, + "+_0 +_3 -_3 -_0": 0.2969830817196037, + "+_0 +_0 -_1 -_1": 0.10489573431122284, + "+_0 +_1 -_0 -_1": 0.10489573431122284, + "+_0 +_2 -_3 -_1": 0.10489573431122284, + "+_0 +_3 -_2 -_1": 0.10489573431122284, + "+_1 +_0 -_1 -_0": 0.10489573431122284, + "+_1 +_1 -_0 -_0": 0.10489573431122284, + "+_1 +_2 -_3 -_0": 0.10489573431122284, + "+_1 +_3 -_2 -_0": 0.10489573431122284, + "+_1 +_0 -_0 -_1": 0.2969830817196037, + "+_1 +_1 -_1 -_1": 0.3113492725921232, + "+_1 +_2 -_2 -_1": 0.2969830817196037, + "+_1 +_3 -_3 -_1": 0.3113492725921232, + "+_2 +_0 -_0 -_2": 0.2965412157060776, + "+_2 +_1 -_1 -_2": 0.2969830817196037, + "+_2 +_2 -_2 -_2": 0.2965412157060776, + "+_2 +_3 -_3 -_2": 0.2969830817196037, + "+_2 +_0 -_1 -_3": 0.10489573431122284, + "+_2 +_1 -_0 -_3": 0.10489573431122284, + "+_2 +_2 -_3 -_3": 0.10489573431122284, + "+_2 +_3 -_2 -_3": 0.10489573431122284, + "+_3 +_0 -_1 -_2": 0.10489573431122284, + "+_3 +_1 -_0 -_2": 0.10489573431122284, + "+_3 +_2 -_3 -_2": 0.10489573431122284, + "+_3 +_3 -_2 -_2": 0.10489573431122284, + "+_3 +_0 -_0 -_3": 0.2969830817196037, + "+_3 +_1 -_1 -_3": 0.3113492725921232, + "+_3 +_2 -_2 -_3": 0.2969830817196037, + "+_3 +_3 -_3 -_3": 0.3113492725921232 + } + }, + { + "distance": 1.3000000000000005, + "nuclear_repulsion_energy": 0.40705939301538446, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.979223491238455, + "+_1 -_1": -0.6482421177110171, + "+_2 -_2": -0.979223491238455, + "+_3 -_3": -0.6482421177110171, + "+_0 +_0 -_0 -_0": 0.28913848684197374, + "+_0 +_1 -_1 -_0": 0.2907933674011718, + "+_0 +_2 -_2 -_0": 0.28913848684197374, + "+_0 +_3 -_3 -_0": 0.2907933674011718, + "+_0 +_0 -_1 -_1": 0.10820872981187372, + "+_0 +_1 -_0 -_1": 0.10820872981187372, + "+_0 +_2 -_3 -_1": 0.10820872981187372, + "+_0 +_3 -_2 -_1": 0.10820872981187372, + "+_1 +_0 -_1 -_0": 0.10820872981187372, + "+_1 +_1 -_0 -_0": 0.10820872981187372, + "+_1 +_2 -_3 -_0": 0.10820872981187372, + "+_1 +_3 -_2 -_0": 0.10820872981187372, + "+_1 +_0 -_0 -_1": 0.2907933674011718, + "+_1 +_1 -_1 -_1": 0.30437281923822035, + "+_1 +_2 -_2 -_1": 0.2907933674011718, + "+_1 +_3 -_3 -_1": 0.30437281923822035, + "+_2 +_0 -_0 -_2": 0.28913848684197374, + "+_2 +_1 -_1 -_2": 0.2907933674011718, + "+_2 +_2 -_2 -_2": 0.28913848684197374, + "+_2 +_3 -_3 -_2": 0.2907933674011718, + "+_2 +_0 -_1 -_3": 0.10820872981187372, + "+_2 +_1 -_0 -_3": 0.10820872981187372, + "+_2 +_2 -_3 -_3": 0.10820872981187372, + "+_2 +_3 -_2 -_3": 0.10820872981187372, + "+_3 +_0 -_1 -_2": 0.10820872981187372, + "+_3 +_1 -_0 -_2": 0.10820872981187372, + "+_3 +_2 -_3 -_2": 0.10820872981187372, + "+_3 +_3 -_2 -_2": 0.10820872981187372, + "+_3 +_0 -_0 -_3": 0.2907933674011718, + "+_3 +_1 -_1 -_3": 0.30437281923822035, + "+_3 +_2 -_2 -_3": 0.2907933674011718, + "+_3 +_3 -_3 -_3": 0.30437281923822035 + } + }, + { + "distance": 1.4000000000000004, + "nuclear_repulsion_energy": 0.37798372208571424, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.9421415514240569, + "+_1 -_1": -0.6584201047909949, + "+_2 -_2": -0.9421415514240569, + "+_3 -_3": -0.6584201047909949, + "+_0 +_0 -_0 -_0": 0.2824093630273007, + "+_0 +_1 -_1 -_0": 0.285086042113072, + "+_0 +_2 -_2 -_0": 0.2824093630273007, + "+_0 +_3 -_3 -_0": 0.285086042113072, + "+_0 +_0 -_1 -_1": 0.11151104453735747, + "+_0 +_1 -_0 -_1": 0.11151104453735747, + "+_0 +_2 -_3 -_1": 0.11151104453735747, + "+_0 +_3 -_2 -_1": 0.11151104453735747, + "+_1 +_0 -_1 -_0": 0.11151104453735747, + "+_1 +_1 -_0 -_0": 0.11151104453735747, + "+_1 +_2 -_3 -_0": 0.11151104453735747, + "+_1 +_3 -_2 -_0": 0.11151104453735747, + "+_1 +_0 -_0 -_1": 0.285086042113072, + "+_1 +_1 -_1 -_1": 0.2978237939319283, + "+_1 +_2 -_2 -_1": 0.285086042113072, + "+_1 +_3 -_3 -_1": 0.2978237939319283, + "+_2 +_0 -_0 -_2": 0.2824093630273007, + "+_2 +_1 -_1 -_2": 0.285086042113072, + "+_2 +_2 -_2 -_2": 0.2824093630273007, + "+_2 +_3 -_3 -_2": 0.285086042113072, + "+_2 +_0 -_1 -_3": 0.11151104453735747, + "+_2 +_1 -_0 -_3": 0.11151104453735747, + "+_2 +_2 -_3 -_3": 0.11151104453735747, + "+_2 +_3 -_2 -_3": 0.11151104453735747, + "+_3 +_0 -_1 -_2": 0.11151104453735747, + "+_3 +_1 -_0 -_2": 0.11151104453735747, + "+_3 +_2 -_3 -_2": 0.11151104453735747, + "+_3 +_3 -_2 -_2": 0.11151104453735747, + "+_3 +_0 -_0 -_3": 0.285086042113072, + "+_3 +_1 -_1 -_3": 0.2978237939319283, + "+_3 +_2 -_2 -_3": 0.285086042113072, + "+_3 +_3 -_3 -_3": 0.2978237939319283 + } + }, + { + "distance": 1.5000000000000004, + "nuclear_repulsion_energy": 0.3527848072799999, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.9081808724683996, + "+_1 -_1": -0.6653369357648333, + "+_2 -_2": -0.9081808724683996, + "+_3 -_3": -0.6653369357648333, + "+_0 +_0 -_0 -_0": 0.27635169153120637, + "+_0 +_1 -_1 -_0": 0.27984207780650605, + "+_0 +_2 -_2 -_0": 0.27635169153120637, + "+_0 +_3 -_3 -_0": 0.27984207780650605, + "+_0 +_0 -_1 -_1": 0.11476796802985095, + "+_0 +_1 -_0 -_1": 0.11476796802985095, + "+_0 +_2 -_3 -_1": 0.11476796802985095, + "+_0 +_3 -_2 -_1": 0.11476796802985095, + "+_1 +_0 -_1 -_0": 0.11476796802985095, + "+_1 +_1 -_0 -_0": 0.11476796802985095, + "+_1 +_2 -_3 -_0": 0.11476796802985095, + "+_1 +_3 -_2 -_0": 0.11476796802985095, + "+_1 +_0 -_0 -_1": 0.27984207780650605, + "+_1 +_1 -_1 -_1": 0.2917103806018621, + "+_1 +_2 -_2 -_1": 0.27984207780650605, + "+_1 +_3 -_3 -_1": 0.2917103806018621, + "+_2 +_0 -_0 -_2": 0.27635169153120637, + "+_2 +_1 -_1 -_2": 0.27984207780650605, + "+_2 +_2 -_2 -_2": 0.27635169153120637, + "+_2 +_3 -_3 -_2": 0.27984207780650605, + "+_2 +_0 -_1 -_3": 0.11476796802985095, + "+_2 +_1 -_0 -_3": 0.11476796802985095, + "+_2 +_2 -_3 -_3": 0.11476796802985095, + "+_2 +_3 -_2 -_3": 0.11476796802985095, + "+_3 +_0 -_1 -_2": 0.11476796802985095, + "+_3 +_1 -_0 -_2": 0.11476796802985095, + "+_3 +_2 -_3 -_2": 0.11476796802985095, + "+_3 +_3 -_2 -_2": 0.11476796802985095, + "+_3 +_0 -_0 -_3": 0.27984207780650605, + "+_3 +_1 -_1 -_3": 0.2917103806018621, + "+_3 +_2 -_2 -_3": 0.27984207780650605, + "+_3 +_3 -_3 -_3": 0.2917103806018621 + } + }, + { + "distance": 1.6000000000000005, + "nuclear_repulsion_energy": 0.33073575682499995, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.8771718548164869, + "+_1 -_1": -0.6696481150835153, + "+_2 -_2": -0.8771718548164869, + "+_3 -_3": -0.6696481150835153, + "+_0 +_0 -_0 -_0": 0.2709377514309586, + "+_0 +_1 -_1 -_0": 0.2750368394610199, + "+_0 +_2 -_2 -_0": 0.2709377514309586, + "+_0 +_3 -_3 -_0": 0.2750368394610199, + "+_0 +_0 -_1 -_1": 0.11795064269925415, + "+_0 +_1 -_0 -_1": 0.11795064269925415, + "+_0 +_2 -_3 -_1": 0.11795064269925415, + "+_0 +_3 -_2 -_1": 0.11795064269925415, + "+_1 +_0 -_1 -_0": 0.11795064269925415, + "+_1 +_1 -_0 -_0": 0.11795064269925415, + "+_1 +_2 -_3 -_0": 0.11795064269925415, + "+_1 +_3 -_2 -_0": 0.11795064269925415, + "+_1 +_0 -_0 -_1": 0.2750368394610199, + "+_1 +_1 -_1 -_1": 0.28603150631462976, + "+_1 +_2 -_2 -_1": 0.2750368394610199, + "+_1 +_3 -_3 -_1": 0.28603150631462976, + "+_2 +_0 -_0 -_2": 0.2709377514309586, + "+_2 +_1 -_1 -_2": 0.2750368394610199, + "+_2 +_2 -_2 -_2": 0.2709377514309586, + "+_2 +_3 -_3 -_2": 0.2750368394610199, + "+_2 +_0 -_1 -_3": 0.11795064269925415, + "+_2 +_1 -_0 -_3": 0.11795064269925415, + "+_2 +_2 -_3 -_3": 0.11795064269925415, + "+_2 +_3 -_2 -_3": 0.11795064269925415, + "+_3 +_0 -_1 -_2": 0.11795064269925415, + "+_3 +_1 -_0 -_2": 0.11795064269925415, + "+_3 +_2 -_3 -_2": 0.11795064269925415, + "+_3 +_3 -_2 -_2": 0.11795064269925415, + "+_3 +_0 -_0 -_3": 0.2750368394610199, + "+_3 +_1 -_1 -_3": 0.28603150631462976, + "+_3 +_2 -_2 -_3": 0.2750368394610199, + "+_3 +_3 -_3 -_3": 0.28603150631462976 + } + }, + { + "distance": 1.7000000000000004, + "nuclear_repulsion_energy": 0.31128071230588233, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.8489322938195326, + "+_1 -_1": -0.6718961876443492, + "+_2 -_2": -0.8489322938195326, + "+_3 -_3": -0.6718961876443492, + "+_0 +_0 -_0 -_0": 0.2661231241909454, + "+_0 +_1 -_1 -_0": 0.2706415871766125, + "+_0 +_2 -_2 -_0": 0.2661231241909454, + "+_0 +_3 -_3 -_0": 0.2706415871766125, + "+_0 +_0 -_1 -_1": 0.12103641925955475, + "+_0 +_1 -_0 -_1": 0.12103641925955475, + "+_0 +_2 -_3 -_1": 0.12103641925955475, + "+_0 +_3 -_2 -_1": 0.12103641925955475, + "+_1 +_0 -_1 -_0": 0.12103641925955475, + "+_1 +_1 -_0 -_0": 0.12103641925955475, + "+_1 +_2 -_3 -_0": 0.12103641925955475, + "+_1 +_3 -_2 -_0": 0.12103641925955475, + "+_1 +_0 -_0 -_1": 0.2706415871766125, + "+_1 +_1 -_1 -_1": 0.2807761913950995, + "+_1 +_2 -_2 -_1": 0.2706415871766125, + "+_1 +_3 -_3 -_1": 0.2807761913950995, + "+_2 +_0 -_0 -_2": 0.2661231241909454, + "+_2 +_1 -_1 -_2": 0.2706415871766125, + "+_2 +_2 -_2 -_2": 0.2661231241909454, + "+_2 +_3 -_3 -_2": 0.2706415871766125, + "+_2 +_0 -_1 -_3": 0.12103641925955475, + "+_2 +_1 -_0 -_3": 0.12103641925955475, + "+_2 +_2 -_3 -_3": 0.12103641925955475, + "+_2 +_3 -_2 -_3": 0.12103641925955475, + "+_3 +_0 -_1 -_2": 0.12103641925955475, + "+_3 +_1 -_0 -_2": 0.12103641925955475, + "+_3 +_2 -_3 -_2": 0.12103641925955475, + "+_3 +_3 -_2 -_2": 0.12103641925955475, + "+_3 +_0 -_0 -_3": 0.2706415871766125, + "+_3 +_1 -_1 -_3": 0.2807761913950995, + "+_3 +_2 -_2 -_3": 0.2706415871766125, + "+_3 +_3 -_3 -_3": 0.2807761913950995 + } + }, + { + "distance": 1.8000000000000005, + "nuclear_repulsion_energy": 0.29398733939999994, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.8232722658032726, + "+_1 -_1": -0.6725232649640852, + "+_2 -_2": -0.8232722658032726, + "+_3 -_3": -0.6725232649640852, + "+_0 +_0 -_0 -_0": 0.261854522139784, + "+_0 +_1 -_1 -_0": 0.26662513918541925, + "+_0 +_2 -_2 -_0": 0.261854522139784, + "+_0 +_3 -_3 -_0": 0.26662513918541925, + "+_0 +_0 -_1 -_1": 0.12400849673976974, + "+_0 +_1 -_0 -_1": 0.12400849673976974, + "+_0 +_2 -_3 -_1": 0.12400849673976974, + "+_0 +_3 -_2 -_1": 0.12400849673976974, + "+_1 +_0 -_1 -_0": 0.12400849673976974, + "+_1 +_1 -_0 -_0": 0.12400849673976974, + "+_1 +_2 -_3 -_0": 0.12400849673976974, + "+_1 +_3 -_2 -_0": 0.12400849673976974, + "+_1 +_0 -_0 -_1": 0.26662513918541925, + "+_1 +_1 -_1 -_1": 0.2759251044785653, + "+_1 +_2 -_2 -_1": 0.26662513918541925, + "+_1 +_3 -_3 -_1": 0.2759251044785653, + "+_2 +_0 -_0 -_2": 0.261854522139784, + "+_2 +_1 -_1 -_2": 0.26662513918541925, + "+_2 +_2 -_2 -_2": 0.261854522139784, + "+_2 +_3 -_3 -_2": 0.26662513918541925, + "+_2 +_0 -_1 -_3": 0.12400849673976974, + "+_2 +_1 -_0 -_3": 0.12400849673976974, + "+_2 +_2 -_3 -_3": 0.12400849673976974, + "+_2 +_3 -_2 -_3": 0.12400849673976974, + "+_3 +_0 -_1 -_2": 0.12400849673976974, + "+_3 +_1 -_0 -_2": 0.12400849673976974, + "+_3 +_2 -_3 -_2": 0.12400849673976974, + "+_3 +_3 -_2 -_2": 0.12400849673976974, + "+_3 +_0 -_0 -_3": 0.26662513918541925, + "+_3 +_1 -_1 -_3": 0.2759251044785653, + "+_3 +_2 -_2 -_3": 0.26662513918541925, + "+_3 +_3 -_3 -_3": 0.2759251044785653 + } + }, + { + "distance": 1.9000000000000006, + "nuclear_repulsion_energy": 0.278514321536842, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7999992999605494, + "+_1 -_1": -0.6718851324841213, + "+_2 -_2": -0.7999992999605494, + "+_3 -_3": -0.6718851324841213, + "+_0 +_0 -_0 -_0": 0.25807571674548974, + "+_0 +_1 -_1 -_0": 0.2629554026891064, + "+_0 +_2 -_2 -_0": 0.25807571674548974, + "+_0 +_3 -_3 -_0": 0.2629554026891064, + "+_0 +_0 -_1 -_1": 0.12685521390630716, + "+_0 +_1 -_0 -_1": 0.12685521390630716, + "+_0 +_2 -_3 -_1": 0.12685521390630716, + "+_0 +_3 -_2 -_1": 0.12685521390630716, + "+_1 +_0 -_1 -_0": 0.12685521390630716, + "+_1 +_1 -_0 -_0": 0.12685521390630716, + "+_1 +_2 -_3 -_0": 0.12685521390630716, + "+_1 +_3 -_2 -_0": 0.12685521390630716, + "+_1 +_0 -_0 -_1": 0.2629554026891064, + "+_1 +_1 -_1 -_1": 0.2714531263016544, + "+_1 +_2 -_2 -_1": 0.2629554026891064, + "+_1 +_3 -_3 -_1": 0.2714531263016544, + "+_2 +_0 -_0 -_2": 0.25807571674548974, + "+_2 +_1 -_1 -_2": 0.2629554026891064, + "+_2 +_2 -_2 -_2": 0.25807571674548974, + "+_2 +_3 -_3 -_2": 0.2629554026891064, + "+_2 +_0 -_1 -_3": 0.12685521390630716, + "+_2 +_1 -_0 -_3": 0.12685521390630716, + "+_2 +_2 -_3 -_3": 0.12685521390630716, + "+_2 +_3 -_2 -_3": 0.12685521390630716, + "+_3 +_0 -_1 -_2": 0.12685521390630716, + "+_3 +_1 -_0 -_2": 0.12685521390630716, + "+_3 +_2 -_3 -_2": 0.12685521390630716, + "+_3 +_3 -_2 -_2": 0.12685521390630716, + "+_3 +_0 -_0 -_3": 0.2629554026891064, + "+_3 +_1 -_1 -_3": 0.2714531263016544, + "+_3 +_2 -_2 -_3": 0.2629554026891064, + "+_3 +_3 -_3 -_3": 0.2714531263016544 + } + }, + { + "distance": 2.0000000000000004, + "nuclear_repulsion_energy": 0.26458860545999996, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7789220360818254, + "+_1 -_1": -0.6702666718288369, + "+_2 -_2": -0.7789220360818254, + "+_3 -_3": -0.6702666718288369, + "+_0 +_0 -_0 -_0": 0.25473140621314905, + "+_0 +_1 -_1 -_0": 0.2596006290647682, + "+_0 +_2 -_2 -_0": 0.25473140621314905, + "+_0 +_3 -_3 -_0": 0.2596006290647682, + "+_0 +_0 -_1 -_1": 0.12956923744052837, + "+_0 +_1 -_0 -_1": 0.12956923744052837, + "+_0 +_2 -_3 -_1": 0.12956923744052837, + "+_0 +_3 -_2 -_1": 0.12956923744052837, + "+_1 +_0 -_1 -_0": 0.12956923744052837, + "+_1 +_1 -_0 -_0": 0.12956923744052837, + "+_1 +_2 -_3 -_0": 0.12956923744052837, + "+_1 +_3 -_2 -_0": 0.12956923744052837, + "+_1 +_0 -_0 -_1": 0.2596006290647682, + "+_1 +_1 -_1 -_1": 0.2673320597646799, + "+_1 +_2 -_2 -_1": 0.2596006290647682, + "+_1 +_3 -_3 -_1": 0.2673320597646799, + "+_2 +_0 -_0 -_2": 0.25473140621314905, + "+_2 +_1 -_1 -_2": 0.2596006290647682, + "+_2 +_2 -_2 -_2": 0.25473140621314905, + "+_2 +_3 -_3 -_2": 0.2596006290647682, + "+_2 +_0 -_1 -_3": 0.12956923744052837, + "+_2 +_1 -_0 -_3": 0.12956923744052837, + "+_2 +_2 -_3 -_3": 0.12956923744052837, + "+_2 +_3 -_2 -_3": 0.12956923744052837, + "+_3 +_0 -_1 -_2": 0.12956923744052837, + "+_3 +_1 -_0 -_2": 0.12956923744052837, + "+_3 +_2 -_3 -_2": 0.12956923744052837, + "+_3 +_3 -_2 -_2": 0.12956923744052837, + "+_3 +_0 -_0 -_3": 0.2596006290647682, + "+_3 +_1 -_1 -_3": 0.2673320597646799, + "+_3 +_2 -_2 -_3": 0.2596006290647682, + "+_3 +_3 -_3 -_3": 0.2673320597646799 + } + }, + { + "distance": 2.1000000000000005, + "nuclear_repulsion_energy": 0.25198914805714284, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7598527398789557, + "+_1 -_1": -0.6678962302233551, + "+_2 -_2": -0.7598527398789557, + "+_3 -_3": -0.6678962302233551, + "+_0 +_0 -_0 -_0": 0.25176934004198576, + "+_0 +_1 -_1 -_0": 0.2565303480600458, + "+_0 +_2 -_2 -_0": 0.25176934004198576, + "+_0 +_3 -_3 -_0": 0.2565303480600458, + "+_0 +_0 -_1 -_1": 0.13214678303978122, + "+_0 +_1 -_0 -_1": 0.13214678303978122, + "+_0 +_2 -_3 -_1": 0.13214678303978122, + "+_0 +_3 -_2 -_1": 0.13214678303978122, + "+_1 +_0 -_1 -_0": 0.13214678303978122, + "+_1 +_1 -_0 -_0": 0.13214678303978122, + "+_1 +_2 -_3 -_0": 0.13214678303978122, + "+_1 +_3 -_2 -_0": 0.13214678303978122, + "+_1 +_0 -_0 -_1": 0.2565303480600458, + "+_1 +_1 -_1 -_1": 0.26353296310021446, + "+_1 +_2 -_2 -_1": 0.2565303480600458, + "+_1 +_3 -_3 -_1": 0.26353296310021446, + "+_2 +_0 -_0 -_2": 0.25176934004198576, + "+_2 +_1 -_1 -_2": 0.2565303480600458, + "+_2 +_2 -_2 -_2": 0.25176934004198576, + "+_2 +_3 -_3 -_2": 0.2565303480600458, + "+_2 +_0 -_1 -_3": 0.13214678303978122, + "+_2 +_1 -_0 -_3": 0.13214678303978122, + "+_2 +_2 -_3 -_3": 0.13214678303978122, + "+_2 +_3 -_2 -_3": 0.13214678303978122, + "+_3 +_0 -_1 -_2": 0.13214678303978122, + "+_3 +_1 -_0 -_2": 0.13214678303978122, + "+_3 +_2 -_3 -_2": 0.13214678303978122, + "+_3 +_3 -_2 -_2": 0.13214678303978122, + "+_3 +_0 -_0 -_3": 0.2565303480600458, + "+_3 +_1 -_1 -_3": 0.26353296310021446, + "+_3 +_2 -_2 -_3": 0.2565303480600458, + "+_3 +_3 -_3 -_3": 0.26353296310021446 + } + }, + { + "distance": 2.2000000000000006, + "nuclear_repulsion_energy": 0.2405350958727272, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7426094533311526, + "+_1 -_1": -0.6649574082258723, + "+_2 -_2": -0.7426094533311526, + "+_3 -_3": -0.6649574082258723, + "+_0 +_0 -_0 -_0": 0.2491412303992094, + "+_0 +_1 -_1 -_0": 0.25371599331470235, + "+_0 +_2 -_2 -_0": 0.2491412303992094, + "+_0 +_3 -_3 -_0": 0.25371599331470235, + "+_0 +_0 -_1 -_1": 0.13458692796924263, + "+_0 +_1 -_0 -_1": 0.13458692796924263, + "+_0 +_2 -_3 -_1": 0.13458692796924263, + "+_0 +_3 -_2 -_1": 0.13458692796924263, + "+_1 +_0 -_1 -_0": 0.13458692796924263, + "+_1 +_1 -_0 -_0": 0.13458692796924263, + "+_1 +_2 -_3 -_0": 0.13458692796924263, + "+_1 +_3 -_2 -_0": 0.13458692796924263, + "+_1 +_0 -_0 -_1": 0.25371599331470235, + "+_1 +_1 -_1 -_1": 0.2600278656476332, + "+_1 +_2 -_2 -_1": 0.25371599331470235, + "+_1 +_3 -_3 -_1": 0.2600278656476332, + "+_2 +_0 -_0 -_2": 0.2491412303992094, + "+_2 +_1 -_1 -_2": 0.25371599331470235, + "+_2 +_2 -_2 -_2": 0.2491412303992094, + "+_2 +_3 -_3 -_2": 0.25371599331470235, + "+_2 +_0 -_1 -_3": 0.13458692796924263, + "+_2 +_1 -_0 -_3": 0.13458692796924263, + "+_2 +_2 -_3 -_3": 0.13458692796924263, + "+_2 +_3 -_2 -_3": 0.13458692796924263, + "+_3 +_0 -_1 -_2": 0.13458692796924263, + "+_3 +_1 -_0 -_2": 0.13458692796924263, + "+_3 +_2 -_3 -_2": 0.13458692796924263, + "+_3 +_3 -_2 -_2": 0.13458692796924263, + "+_3 +_0 -_0 -_3": 0.25371599331470235, + "+_3 +_1 -_1 -_3": 0.2600278656476332, + "+_3 +_2 -_2 -_3": 0.25371599331470235, + "+_3 +_3 -_3 -_3": 0.2600278656476332 + } + }, + { + "distance": 2.3000000000000007, + "nuclear_repulsion_energy": 0.2300770482260869, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7270181595309821, + "+_1 -_1": -0.6615979987912022, + "+_2 -_2": -0.7270181595309821, + "+_3 -_3": -0.6615979987912022, + "+_0 +_0 -_0 -_0": 0.2468029747404954, + "+_0 +_1 -_1 -_0": 0.25113126285911497, + "+_0 +_2 -_2 -_0": 0.2468029747404954, + "+_0 +_3 -_3 -_0": 0.25113126285911497, + "+_0 +_0 -_1 -_1": 0.1368910270708309, + "+_0 +_1 -_0 -_1": 0.1368910270708309, + "+_0 +_2 -_3 -_1": 0.1368910270708309, + "+_0 +_3 -_2 -_1": 0.1368910270708309, + "+_1 +_0 -_1 -_0": 0.1368910270708309, + "+_1 +_1 -_0 -_0": 0.1368910270708309, + "+_1 +_2 -_3 -_0": 0.1368910270708309, + "+_1 +_3 -_2 -_0": 0.1368910270708309, + "+_1 +_0 -_0 -_1": 0.25113126285911497, + "+_1 +_1 -_1 -_1": 0.2567908293356844, + "+_1 +_2 -_2 -_1": 0.25113126285911497, + "+_1 +_3 -_3 -_1": 0.2567908293356844, + "+_2 +_0 -_0 -_2": 0.2468029747404954, + "+_2 +_1 -_1 -_2": 0.25113126285911497, + "+_2 +_2 -_2 -_2": 0.2468029747404954, + "+_2 +_3 -_3 -_2": 0.25113126285911497, + "+_2 +_0 -_1 -_3": 0.1368910270708309, + "+_2 +_1 -_0 -_3": 0.1368910270708309, + "+_2 +_2 -_3 -_3": 0.1368910270708309, + "+_2 +_3 -_2 -_3": 0.1368910270708309, + "+_3 +_0 -_1 -_2": 0.1368910270708309, + "+_3 +_1 -_0 -_2": 0.1368910270708309, + "+_3 +_2 -_3 -_2": 0.1368910270708309, + "+_3 +_3 -_2 -_2": 0.1368910270708309, + "+_3 +_0 -_0 -_3": 0.25113126285911497, + "+_3 +_1 -_1 -_3": 0.2567908293356844, + "+_3 +_2 -_2 -_3": 0.25113126285911497, + "+_3 +_3 -_3 -_3": 0.2567908293356844 + } + }, + { + "distance": 2.4000000000000004, + "nuclear_repulsion_energy": 0.22049050455, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7129148668619978, + "+_1 -_1": -0.6579366094347936, + "+_2 -_2": -0.7129148668619978, + "+_3 -_3": -0.6579366094347936, + "+_0 +_0 -_0 -_0": 0.24471458436009433, + "+_0 +_1 -_1 -_0": 0.2487522713978705, + "+_0 +_2 -_2 -_0": 0.24471458436009433, + "+_0 +_3 -_3 -_0": 0.2487522713978705, + "+_0 +_0 -_1 -_1": 0.13906222157439768, + "+_0 +_1 -_0 -_1": 0.13906222157439768, + "+_0 +_2 -_3 -_1": 0.13906222157439768, + "+_0 +_3 -_2 -_1": 0.13906222157439768, + "+_1 +_0 -_1 -_0": 0.13906222157439768, + "+_1 +_1 -_0 -_0": 0.13906222157439768, + "+_1 +_2 -_3 -_0": 0.13906222157439768, + "+_1 +_3 -_2 -_0": 0.13906222157439768, + "+_1 +_0 -_0 -_1": 0.2487522713978705, + "+_1 +_1 -_1 -_1": 0.25379844304683336, + "+_1 +_2 -_2 -_1": 0.2487522713978705, + "+_1 +_3 -_3 -_1": 0.25379844304683336, + "+_2 +_0 -_0 -_2": 0.24471458436009433, + "+_2 +_1 -_1 -_2": 0.2487522713978705, + "+_2 +_2 -_2 -_2": 0.24471458436009433, + "+_2 +_3 -_3 -_2": 0.2487522713978705, + "+_2 +_0 -_1 -_3": 0.13906222157439768, + "+_2 +_1 -_0 -_3": 0.13906222157439768, + "+_2 +_2 -_3 -_3": 0.13906222157439768, + "+_2 +_3 -_2 -_3": 0.13906222157439768, + "+_3 +_0 -_1 -_2": 0.13906222157439768, + "+_3 +_1 -_0 -_2": 0.13906222157439768, + "+_3 +_2 -_3 -_2": 0.13906222157439768, + "+_3 +_3 -_2 -_2": 0.13906222157439768, + "+_3 +_0 -_0 -_3": 0.2487522713978705, + "+_3 +_1 -_1 -_3": 0.25379844304683336, + "+_3 +_2 -_2 -_3": 0.2487522713978705, + "+_3 +_3 -_3 -_3": 0.25379844304683336 + } + }, + { + "distance": 2.5000000000000004, + "nuclear_repulsion_energy": 0.21167088436799997, + "n_particles": [ + 1, + 1 + ], + "n_spatial_orbitals": 2, + "fermionic_op": { + "+_0 -_0": -0.7001472913640923, + "+_1 -_1": -0.6540677373200052, + "+_2 -_2": -0.7001472913640923, + "+_3 -_3": -0.6540677373200052, + "+_0 +_0 -_0 -_0": 0.24284004931832903, + "+_0 +_1 -_1 -_0": 0.24655755178080657, + "+_0 +_2 -_2 -_0": 0.24284004931832903, + "+_0 +_3 -_3 -_0": 0.24655755178080657, + "+_0 +_0 -_1 -_1": 0.1411050229876932, + "+_0 +_1 -_0 -_1": 0.1411050229876932, + "+_0 +_2 -_3 -_1": 0.1411050229876932, + "+_0 +_3 -_2 -_1": 0.1411050229876932, + "+_1 +_0 -_1 -_0": 0.1411050229876932, + "+_1 +_1 -_0 -_0": 0.1411050229876932, + "+_1 +_2 -_3 -_0": 0.1411050229876932, + "+_1 +_3 -_2 -_0": 0.1411050229876932, + "+_1 +_0 -_0 -_1": 0.24655755178080657, + "+_1 +_1 -_1 -_1": 0.2510298941260374, + "+_1 +_2 -_2 -_1": 0.24655755178080657, + "+_1 +_3 -_3 -_1": 0.2510298941260374, + "+_2 +_0 -_0 -_2": 0.24284004931832903, + "+_2 +_1 -_1 -_2": 0.24655755178080657, + "+_2 +_2 -_2 -_2": 0.24284004931832903, + "+_2 +_3 -_3 -_2": 0.24655755178080657, + "+_2 +_0 -_1 -_3": 0.1411050229876932, + "+_2 +_1 -_0 -_3": 0.1411050229876932, + "+_2 +_2 -_3 -_3": 0.1411050229876932, + "+_2 +_3 -_2 -_3": 0.1411050229876932, + "+_3 +_0 -_1 -_2": 0.1411050229876932, + "+_3 +_1 -_0 -_2": 0.1411050229876932, + "+_3 +_2 -_3 -_2": 0.1411050229876932, + "+_3 +_3 -_2 -_2": 0.1411050229876932, + "+_3 +_0 -_0 -_3": 0.24655755178080657, + "+_3 +_1 -_1 -_3": 0.2510298941260374, + "+_3 +_2 -_2 -_3": 0.24655755178080657, + "+_3 +_3 -_3 -_3": 0.2510298941260374 + } + } +] From 18fb0586cbc8d7815c1ca13e9109b4f927612581 Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Mon, 24 Jun 2024 16:37:51 +0200 Subject: [PATCH 8/9] commented out use of matplotlib --- examples/hydrogen_qiskit.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/hydrogen_qiskit.py b/examples/hydrogen_qiskit.py index 66c1c9ca..2d96fa3b 100644 --- a/examples/hydrogen_qiskit.py +++ b/examples/hydrogen_qiskit.py @@ -5,7 +5,6 @@ from pathlib import Path from typing import Any -import matplotlib.pyplot as plt import numpy as np from qiskit import transpile from qiskit.primitives import BackendEstimator @@ -54,7 +53,7 @@ def calculate_H0(backend: QuantumInspireBackend, distance: float = 0.735) -> _Gr def execute(qi: QuantumInterface) -> None: - distances = np.arange(0.3, 2.5, 0.1) + distances = np.arange(0.3, 0.5, 0.1) results = [] for distance in distances: ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) @@ -86,12 +85,13 @@ def finalize(results: Any) -> dict[str, Any]: print("=== Execute ===\n", results) # plot total energy vs distance between atoms - distances, energies = [[result[key] for result in results] for key in ["distance", "total_energy"]] - plt.plot(distances, energies) - plt.xlabel("Distance (Angstrom)") - plt.ylabel("Total energy (a.u.)") - - plt.show() + # import matplotlib.pyplot as plt + # distances, energies = [[result[key] for result in results] for key in ["distance", "total_energy"]] + # plt.plot(distances, energies) + # plt.xlabel("Distance (Angstrom)") + # plt.ylabel("Total energy (a.u.)") + # + # plt.show() # draw optimal circuit of first distance as text circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) From 1c389ad9f9bc9f444e1d1b598b2cd484225a563e Mon Sep 17 00:00:00 2001 From: Harold Meerwaldt Date: Tue, 25 Jun 2024 10:28:49 +0200 Subject: [PATCH 9/9] removed passing VQEResult --- examples/hydrogen_qiskit.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/examples/hydrogen_qiskit.py b/examples/hydrogen_qiskit.py index 2d96fa3b..86c00c4e 100644 --- a/examples/hydrogen_qiskit.py +++ b/examples/hydrogen_qiskit.py @@ -57,7 +57,7 @@ def execute(qi: QuantumInterface) -> None: results = [] for distance in distances: ground_state_energy_results = calculate_H0(backend=QuantumInspireBackend(qi), distance=distance) - result = dataclasses.asdict(ground_state_energy_results) + result = {} result["total_energy"] = ground_state_energy_results.nuclear_repulsion_energy + ground_state_energy_results.result.eigenvalue result["distance"] = distance results.append(result) @@ -92,9 +92,3 @@ def finalize(results: Any) -> dict[str, Any]: # plt.ylabel("Total energy (a.u.)") # # plt.show() - - # draw optimal circuit of first distance as text - circuit = transpile(results[0]["result"].optimal_circuit, basis_gates=['ry', 'h', 'cx', 'x', 'sdg', 'rz', 's']) - print(circuit.draw("text")) - -