02_forging_with_quantum_serverless.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "52acc23d",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Tutorial 2: Entanglement Forging with Quantum Serverless\n",
    "**March 02, 2023 <br/>**\n",
    "**For SCA2023: Future of HPC with Quantum Workshop<br>**\n",
    "This tutorial was generated from [Circuit Knitting toolbox docs](https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/blob/main/docs/tutorials/entanglement_forging/) and [Quantum Serverless docs](https://github.com/Qiskit-Extensions/quantum-serverless/tree/main/docs)\n",
    "\n",
    "**Entanglement forging** is a method which allows us to represent expectation values of a 2n-qubit wavefunction as sums of multiple expectation values of n-qubit states, embedded in a classical optimization, thus doubling the size of the system that can be exactly simulated with a fixed number of qubits.\n",
    "\n",
    "See [Tutorial 1](https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/blob/main/docs/tutorials/entanglement_forging/tutorial_1_getting_started.ipynb) for a high-level breakdown of the entanglement forging algorithm, or check out the [explanatory material](https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/blob/main/docs/explanation/entanglement_forging/index.rst) for a more detailed explanation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc09a63-5770-43e7-9679-8ba20caa1037",
   "metadata": {},
   "source": [
    "### Adapting entanglement forging for use with `Quantum Serverless`\n",
    "\n",
    "[**Quantum Serverless**](https://github.com/Qiskit-Extensions/quantum-serverless) is a platform built to enable distributed computing across a variety of classical and quantum backends.\n",
    "\n",
    "In this demo, we will show how to configure a ground state workflow with entanglement forging and seamlessly adapt it to run entirely on the cloud using Quantum Serverless.\n",
    "\n",
    "<img src=\"images/forging_with_serverless.png\" width = 50%>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3d50836-48a1-4992-a1fb-12c45701a08b",
   "metadata": {},
   "source": [
    "### Instantiate the `ElectronicStructureProblem`\n",
    "\n",
    "For this tutorial, we will model a system in which H2O is split on a magnesium surface, as described in **Fig. 1(a)** from [arXiv:2203.07536](https://arxiv.org/abs/2203.07536). In particular, we'll compute the ground state energy of the reactant in this reaction. Entanglement forging reduces the total number of qubits needed from 4 to 2.\n",
    "\n",
    "<img src=\"images/mg_structure.png\" width = 50%>\n",
    "\n",
    "Here we read in the system information, populate an `IntegralDriver` object from `Circuit Knitting Toolbox`, and use that driver to instantiate an `ElectronicStructureProblem` from Qiskit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bae153d-393e-49ba-8abd-596e6c43052e",
   "metadata": {},
   "source": [
    "## Entanglement forging overview\n",
    "\n",
    "Entanglement forging [2] was introduced as a way to reduce the number of qubits necessary to perform quantum simulation of chemical or physical systems. In general, to simulate n orbitals in a chemistry problem, one typically needs 2n qubits. Entanglement Forging makes it possible to represent expectation values of a 2n-qubit wavefunction as sums of multiple expectation values of n-qubit states, embedded in a classical computation, thus doubling the size of the system that can be exactly simulated with a fixed number of qubits.\n",
    "\n",
    "Furthermore, Entanglement Forging permits the circuits necessary for the n-qubit simulations to be shallower, relaxing requirements on gate error and connectivity, at the cost of increased quantum and classical run times.\n",
    "\n",
    "The schematic below outlines how the expectation value M of a 2n-qubit wavefunction |ψ>2n with respect to a 2n-qubit Hamiltonian H2n can be decomposed into a sum of expectation values of products of n-qubit wavefunctions with respect to n-qubit operators. These n-qubit expectation values correspond to sub-experiments.\n",
    "\n",
    "<img src=\"images/forging_info_graphic.png\" width = 70%>\n",
    "\n",
    "1. **Decompose**:\n",
    "    * Decompose the 2n-qubit ansatz (wavefunction) into many parameterized, n-qubit ansatze\n",
    "    * Decompose the 2n-qubit observable (Hamiltonian) into many n-qubit observables\n",
    "\n",
    "\n",
    "2. **Evaluate**:\n",
    "    * Use the n-qubit expectation values to reconstruct an estimation of the original 2n-qubit expectation value\n",
    "  \n",
    "  \n",
    "3. **Reconstruct** \n",
    "    * Use the expectation values to reconstruct an estimation of the expectation value for the 2n-qubit system\n",
    "  \n",
    "  \n",
    "4. **If the expectation value (energy) has not converged, update the ansatze parameters and continue with Step 2**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf77d79",
   "metadata": {},
   "source": [
    "### Instantiate the `ElectronicStructureProblem`\n",
    "\n",
    "For this tutorial, we will model a system in which H2O is split on a magnesium surface, as described in Fig. 1(a) from [arXiv:2203.07536](https://arxiv.org/abs/2203.07536). In particular, we'll compute the ground state energy of the reactant in this reaction. Entanglement forging reduces the total number of qubits needed from 4 to 2.\n",
    "\n",
    "Here we read in the system information, populate an `IntegralDriver` object from `Circuit Knitting Toolbox`, and use that driver to instantiate an `ElectronicStructureProblem` from Qiskit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4173c15e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import numpy as np\n",
    "!pip install quantum_serverless --quiet\n",
    "!pip install circuit-knitting-toolbox --quiet\n",
    "from qiskit_nature.problems.second_quantization import ElectronicStructureProblem\n",
    "from circuit_knitting_toolbox.utils import IntegralDriver\n",
    "\n",
    "system_data = np.load(\"reactant_2mo.npz\")\n",
    "num_molecular_orbitals = 2\n",
    "\n",
    "driver = IntegralDriver(\n",
    "    hcore=system_data[\"h1\"],\n",
    "    mo_coeff=system_data[\"HF_mo_coeff\"],\n",
    "    eri=system_data[\"Gamma_eri\"],\n",
    "    num_alpha=system_data[\"na\"],\n",
    "    num_beta=system_data[\"nb\"],\n",
    "    nuclear_repulsion_energy=system_data[\"h0\"],\n",
    ")\n",
    "\n",
    "problem = ElectronicStructureProblem(driver)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "453dde4f",
   "metadata": {},
   "source": [
    "### Configure the entanglement forging specific inputs\n",
    "\n",
    "The ansatz for Entanglement Forging consists of a set of input bitstrings and a parameterized circuit.  (See the [explanatory material](https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/blob/main/docs/explanation/entanglement_forging/index.rst) for additional background on the method). For this demo, we will use the same bitstrings and ansatz for both the U and V subsystems, and we will use the [TwoLocal](https://qiskit.org/documentation/stubs/qiskit.circuit.library.TwoLocal.html) circuit from Qiskit, along with [hop gates](https://doi.org/10.1103/PRXQuantum.3.010309)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f25814e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hop gate:\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 447.652x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit import QuantumCircuit, Parameter\n",
    "\n",
    "theta = Parameter(\"θ\")\n",
    "\n",
    "hop_gate = QuantumCircuit(2, name=\"hop_gate\")\n",
    "hop_gate.h(0)\n",
    "hop_gate.cx(1, 0)\n",
    "hop_gate.cx(0, 1)\n",
    "hop_gate.ry(-theta, 0)\n",
    "hop_gate.ry(-theta, 1)\n",
    "hop_gate.cx(0, 1)\n",
    "hop_gate.h(0)\n",
    "\n",
    "print(f\"Hop gate:\\n\")\n",
    "hop_gate.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "67d53b1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 206.852x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit.library import TwoLocal\n",
    "from circuit_knitting_toolbox.entanglement_forging import EntanglementForgingAnsatz\n",
    "\n",
    "entangler_map = [[0, 1]]\n",
    "bitstrings_u = [(1, 0), (0, 1)]\n",
    "\n",
    "circuit_u = TwoLocal(num_molecular_orbitals, [], hop_gate, entangler_map, reps=1)\n",
    "ansatz = EntanglementForgingAnsatz(\n",
    "    circuit_u=circuit_u,\n",
    "    bitstrings_u=bitstrings_u,\n",
    ")\n",
    "ansatz.circuit_u.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a88fe497",
   "metadata": {},
   "source": [
    "### Set up the Qiskit Runtime Service\n",
    "\n",
    "The Qiskit Runtime Service provides access to Qiskit Runtime Primitives and quantum backends. See the [Qiskit Runtime documentation](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/) for more information.  Here, we specify the backend(s) to be used to evaluate the circuits. Backends could be [simulator(s) and/or quantum device(s)](https://quantum-computing.ibm.com/services/resources?tab=systems).\n",
    "\n",
    "Alternatively, if a Qiskit Runtime Service is not passed, then a local simulator will be used with the [Qiskit Primitives](https://qiskit.org/documentation/apidoc/primitives.html), and the `backend_names` argument will be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "76453753",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_runtime import QiskitRuntimeService, Options\n",
    "\n",
    "# Uncomment the following line to instead use the Qiskit Runtime Service.\n",
    "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n",
    "\n",
    "# By default, use a local simulator to implement the Qiskit Runtime Primitives\n",
    "service = None\n",
    "\n",
    "backend_names = [\"ibmq_qasm_simulator\"] * 2\n",
    "# backend_names = [\"ibmq_lima\", \"ibmq_belem\"]\n",
    "\n",
    "# If a single set of options are passed, it will be applied to all backends\n",
    "options = [Options(execution={\"shots\": 1000}), Options(execution={\"shots\": 2000})]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b77cbc9",
   "metadata": {},
   "source": [
    "### Set up Quantum Serverless\n",
    "\n",
    "We can use Quantum Serverless to send the entanglement forging routine to a remote compute resource. For this tutorial, we will use our local CPU cores as the compute cluster. See the [Quantum Serverless](https://github.com/Qiskit-Extensions/quantum-serverless) documentation (and below) for more information about how to use other clusters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468f3c46-b817-4e81-96a2-5b92729f46e9",
   "metadata": {},
   "source": [
    "**Compute resources**\n",
    "\n",
    "Compute resources can be described as set of computational nodes with resources associated to each of them.\n",
    "Nodes are performing computation itself. \n",
    "Distributed storage is for accessing sharable resources between nodes.\n",
    "\n",
    "![compute resources](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagrams_compute_resource.png)\n",
    "\n",
    "\n",
    "In order to resolve distributed compute we need a way to orchestrate our workloads on remote resources.\n",
    "\n",
    "**Object**\n",
    "\n",
    "Let's first look how to turn a local object into a remote one.\n",
    "\n",
    "To turn your local object to distributed one you need to call `put` function. \n",
    "It will serialize your object and send it to distributed storage and return you a reference to remote object location. \n",
    "\n",
    "![objects diagram](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagrams_put.png)\n",
    "\n",
    "Example\n",
    "\n",
    "```python\n",
    "cirucit = QuantumCircuit(N, M)\n",
    "...\n",
    "circuit_reference = quantum_serverless.put(circuit)\n",
    "```\n",
    "\n",
    "Now we know how to move local object to remote compute resource. \n",
    "Next we need to do something with it. For this we will have remote functions.\n",
    "\n",
    "**Functions**\n",
    "\n",
    "As a second step we need to know how to transform our local function into remote one. \n",
    "\n",
    "In order to do that you need to annotate function with `run_qiskit_remote` decorator. \n",
    "This will turn your function into remote executable.  \n",
    "\n",
    "![functions diagram](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagrams_function.png)\n",
    "\n",
    "All you need to do now is call this function and it will be executed as a remote procedure automatically. \n",
    "\n",
    "If you run N instances of this function in parallel you need just call it N times in a loop. \n",
    "The result of the following code will be a list of references to execution results.\n",
    "\n",
    "Example\n",
    "\n",
    "```python\n",
    "@quantum_serverless.run_qiskit_remote()\n",
    "def exp_val_remote(cirucit, obs):\n",
    "    estimator = Estimator(...)\n",
    "    return estimator.run(circuit, obs)\n",
    "\n",
    "obs: Operator = ...\n",
    "\n",
    "exp_val_execution_reference = exp_val_remote(circuit, obs)\n",
    "\n",
    "circuit_list: List[QuantumCircuit] = [...]\n",
    "\n",
    "obs_ref = quantum_serverless.put(obs)\n",
    "\n",
    "exp_val_execution_references = [\n",
    "    exp_val_remote(circ, obs_ref) \n",
    "    for circ in circuit_list\n",
    "]\n",
    "```\n",
    "\n",
    "As you can see we are passing an observable by refernce and circuits by values. Attributes passed by value will be converted to remote objects automatically and resolved within the remote function. We are passing observable by referece because we know it is the same one shared by all parallel function invocations, so we are saving some space. \n",
    "\n",
    "**Collecting results**\n",
    "\n",
    "And of course you need to collect your results back from remote resources. \n",
    "In order to do that you need to call the `get` function, which can be applied to object and function references or, alternatively, to a list of references.\n",
    "\n",
    "![collecting results diagram](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagram_get.png)\n",
    "\n",
    "Example\n",
    "\n",
    "```python\n",
    "collected_circuit = quantum_serverless.get(circuit_reference)\n",
    "# <QuantumCircuit ...>\n",
    "\n",
    "collected_exp_value = quantum_serverless.get(exp_val_execution_reference)\n",
    "# <EstimatorResult ...>\n",
    "collected_exp_values = quantum_serverless.get(exp_val_execution_references)\n",
    "# [<EstimatorResult ...>, <EstimatorResult ...>, ...]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12048a2a-c1a3-45af-ad79-4794bb9d72f9",
   "metadata": {},
   "source": [
    "**Resource allocation**\n",
    "\n",
    "Some functions are more demanding than others. \n",
    "To allocate specific resources to a function, the decorator accepts `target` parameter.\n",
    "For example, your function may require 2 cpus to be executed. You can pass `target={'cpu': 2}` to decorator and this function will request 2 cpus from your resource capacity to be executed.\n",
    "\n",
    "![resource allocation diagram](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagrams_resource_allocation.png)\n",
    "\n",
    "Example\n",
    "\n",
    "```python\n",
    "@quantum_serverless.run_qiskit_remote(target={\"cpu\": 2, \"mem\": 8})\n",
    "def exp_val_remote(cirucit, obs):\n",
    "    estimator = Estimator(...)\n",
    "    exp_val_result = estimator.run(circuit, obs)\n",
    "    ...\n",
    "    return result\n",
    "```\n",
    "\n",
    "**Execution management**\n",
    "\n",
    "Now we figured how to convert our function and objects into remote counterparts and how to request for specific resources.\n",
    "Next step would be deciding where to run your workloads. \n",
    "\n",
    "To have control over location of compute we use configurations in `QuantumServerless` object and python context managers. \n",
    "\n",
    "`QuantumServerless` has a notion of `providers` which are abstractions to define where your compute resources are located.\n",
    "\n",
    "By default you always have a `local` provider which is your local machine where nodes and local cores.\n",
    "And you can configure as many providers as you want.\n",
    "\n",
    "![execution management diagram](https://raw.githubusercontent.com/Qiskit-Extensions/quantum-serverless/main/docs/tutorials/images/diagrams_context_management.png)\n",
    "\n",
    "Example\n",
    "\n",
    "```python\n",
    "serverless = QuantumServerless({\"providers\": [...]})\n",
    "serverless = QuantumServerless.load_configuration(\"<PATH_TO_CONFIG_FILE>\")\n",
    "print(serverless)\n",
    "# <QuantumServerless: providers [local, ibm-cloud, ...]>\n",
    "\n",
    "with serverless.context(\"local\"):\n",
    "    exp_val_execution_reference = exp_val_remote(circuit, obs)\n",
    "    collected_exp_value = quantum_serverless.get(exp_val_execution_reference)\n",
    "\n",
    "with serverless.context(\"ibm-cloud\"):\n",
    "    exp_val_execution_reference = exp_val_remote(circuit, obs)\n",
    "    collected_exp_value = quantum_serverless.get(exp_val_execution_reference)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ec28c8e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<Provider: local>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from quantum_serverless import QuantumServerless\n",
    "\n",
    "serverless = QuantumServerless()\n",
    "serverless.providers()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e00110ce",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Create a wrapper function to send to the remote cluster\n",
    "\n",
    "Use Quantum Serverless to send the `solve_remote` method to a remote cluster.\n",
    "\n",
    "Here we create a wrapper function for `EntanglementForgingGroundStateSolver` and its `solve` method, and we annotate it with the `@run_qiskit_remote()` decorator from Quantum Serverless. This allows us to call this function from a serverless context and have it sent for remote execution on the specified cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a940a226",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, Sequence, Tuple, Dict, Union\n",
    "from qiskit.algorithms.optimizers import Optimizer\n",
    "from qiskit.result import Result\n",
    "from quantum_serverless import run_qiskit_remote\n",
    "from circuit_knitting_toolbox.entanglement_forging import (\n",
    "    EntanglementForgingGroundStateSolver,\n",
    ")\n",
    "\n",
    "\n",
    "@run_qiskit_remote(target={\"cpu\": 2})\n",
    "def solve_remote(\n",
    "    problem: ElectronicStructureProblem,\n",
    "    ansatz: EntanglementForgingAnsatz,\n",
    "    optimizer: Optimizer,\n",
    "    service_args: Optional[Dict] = None,\n",
    "    backend_names: Optional[Union[str, Sequence[str]]] = None,\n",
    "    options_dicts: Optional[Union[Dict, Sequence[Dict]]] = None,\n",
    "    initial_point: Optional[Sequence[float]] = None,\n",
    "    orbitals_to_reduce: Optional[Sequence[int]] = None,\n",
    ") -> Result:\n",
    "    \"\"\"\n",
    "    Wrapper function for running entanglement forging VQE on a remote resource.\n",
    "\n",
    "        Args:\n",
    "            - problem: A class encoding the problem to be solved\n",
    "            - ansatz: The ansatz\n",
    "            - optimizer: Optimizer to use to optimize the ansatz circuit parameters\n",
    "            - service_args: The arguments for instantiating a QiskitRuntimeService\n",
    "            - backend_names: List of backend names to use during parallel computation\n",
    "            - options_dicts: Options to use with backends\n",
    "            - initial_point: Initial values for ansatz parameters\n",
    "            - orbitals_to_reduce: List of orbital indices to remove from the problem before\n",
    "                decomposition.\n",
    "        Returns:\n",
    "            - An interpreted EigenstateResult\n",
    "    \"\"\"\n",
    "    service = QiskitRuntimeService(**service_args) if service_args else None\n",
    "\n",
    "    # Convert options dictionaries into Options objects\n",
    "    options = None\n",
    "    if options_dicts:\n",
    "        if isinstance(options_dicts, Dict):\n",
    "            options_dicts = [options_dicts]\n",
    "        options = [Options(**o) for o in options_dicts]\n",
    "\n",
    "    solver = EntanglementForgingGroundStateSolver(\n",
    "        ansatz=ansatz,\n",
    "        service=service,\n",
    "        optimizer=optimizer,\n",
    "        backend_names=backend_names,\n",
    "        options=options,\n",
    "        initial_point=initial_point,\n",
    "        orbitals_to_reduce=orbitals_to_reduce,\n",
    "    )\n",
    "    result = solver.solve(problem)\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a2b14a5",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Run entanglement forging on a remote cluster\n",
    "\n",
    "Once a user has set up their `ElectronicStructureProblem`, `EntanglementForgingAnsatz`, and other program options, the only thing remaining is call `EntanglementForgingGroundStateSolver.solve`, which we have wrapped in the `solve_remote` function.\n",
    "\n",
    "We will call the `solve_remote` function within a QuantumServerless context, which means it will be run on the specified cluster. Remember, the default cluster for this demo will use the cores on our local CPU. To specify a new cluster, the `QuantumServerless.set_provider` method should be used.\n",
    "\n",
    "When the remote function is called, it will return a \"future\" object, and Python will continue interpreting the next line of code. The `get` function is a blocking command which should be used to retrieve the results of the remote function via the \"future\" object. The program will not continue past the `get` call until the results of the remote function are returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7b890400",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "from dataclasses import asdict\n",
    "from qiskit.algorithms.optimizers import COBYLA, SLSQP, SPSA\n",
    "from quantum_serverless import get\n",
    "\n",
    "optimizer = COBYLA(maxiter = 100)\n",
    "\n",
    "# QiskitRuntimeService is not serializable, so we must convert it to a dictionary before passing to remote function\n",
    "service_args = None if service is None else service.active_account()\n",
    "\n",
    "# The Options class is not serializable, so we must convert it to a dictionary before passing to remote function\n",
    "options_dicts = [asdict(o) for o in options]\n",
    "\n",
    "# serverless.set_provider(\"aws\") or serverless.set_provider(\"ibm\") or serverless.set_provider(\"azure\")\n",
    "with serverless.context():\n",
    "    forging_result_future = solve_remote(\n",
    "        problem,\n",
    "        ansatz,\n",
    "        optimizer,\n",
    "        service_args=service_args,\n",
    "        backend_names=backend_names,\n",
    "        options_dicts=options_dicts,\n",
    "    )\n",
    "    results = get(forging_result_future)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1bee2d-f90e-451b-b921-7ccfb68a1c8b",
   "metadata": {},
   "source": [
    "#### Optional: Guide to multi cloud deployment \n",
    "\n",
    "The guide here shows you step by step how to deploy these resources to be able to load and use that client with your desired configuration https://github.com/Qiskit-Extensions/quantum-serverless/blob/main/docs/guides/08_multi_cloud_deployment.rst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1a66f3f4-3fcd-45f5-a9bf-5893b2851dad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configuration constructor arguments example\n",
    "# serverless = QuantumServerless({\n",
    "#     \"providers\": [{\n",
    "#         \"name\": \"Sca2023_provider\",  # provider name\n",
    "#         \"compute_resource\": { # main computational resource\n",
    "#             \"name\": \"my_resource\", # cluster name\n",
    "#             \"host\": \"HOST_ADDRESS_OF_CLUSTER_HEAD_NODE\", # cluster host address, if you are using helm it will be DEPLOYMENT_NAME-kuberay-head-svc\n",
    "#         }\n",
    "#     }]\n",
    "# })\n",
    "\n",
    "# Other option will be creating an instance from configuration file, which has exactly the same structure as example above.\n",
    "#\n",
    "# serverless = QuantumServerless.load_configuration(\"./serverless_config.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3875019-c180-471d-b9dd-5b6f6a80e805",
   "metadata": {},
   "source": [
    "#### Optional: Running as an async script\n",
    "In most of the cases we want to run our scripts as async programs, so we can lunch them and forget, then later on check results. In order to do so we will use Program interface.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e8dc7523-8eee-4968-8561-3418fd23ca90",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from quantum_serverless import Program\n",
    "#\n",
    "# program = Program(\n",
    "#     name=\"awesome_program\",\n",
    "#     entrypoint=\"some_program.py\",\n",
    "#     working_dir=\"\"./source_files/\"\",\n",
    "#     description=\"description of a program\",\n",
    "#     version=\"0.0.1\"\n",
    "# )\n",
    "#\n",
    "# job = serverless.run_program(program)\n",
    "# job"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9601ac33",
   "metadata": {},
   "source": [
    "\n",
    "### Visualize the results\n",
    "\n",
    "Visualize the convergence of the estimated ground state energy and the Schmidt coefficients as the ansatz parameters are optimized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "97ae8342",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Energy:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Schmidt Coefficients:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAArg0lEQVR4nO3dfXxcV33n8c9Pssa2ZMca2bLj+NmOk9iQxCSKSSA8Jg6B0jiwKSRACS00LW223VK2DYVSXhS6Ybtb2m55tQ0QCE0gCXQB7xIIdnhciIOVYCuOjWNLiWMJW5YtS7Yk27Kk3/5x78jX8oye5s6DZr7v12tecx/OnTmaGc1vzjn3/o65OyIiUr4qCl0BEREpLAUCEZEyp0AgIlLmFAhERMqcAoGISJmbVugKTMa8efN8+fLlha6GiMiU8vTTTx9x9/qR26dkIFi+fDmNjY2FroaIyJRiZvvTbVfXkIhImVMgEBEpcwoEIiJlToFARKTMKRCIiJS5WAKBmd1vZofNbGeG/WZm/2Rm+8ysycyuiuy708z2hrc746iPiIiMX1wtgi8DN4+y/83A6vB2F/AvAGZWB/w18EpgPfDXZpaMqU4iIjIOsQQCd/8J0DlKkY3AVzywFag1s4XAm4DN7t7p7seAzYweUArm8PFTfG/nwUJXQ0QkdvkaI1gEHIist4bbMm0/j5ndZWaNZtbY0dGRs4pm8sWfvcAHH3qGU2cG8/7cIiK5NGUGi939PndvcPeG+vrzrpDOuebDPbjDsb7+vD+3iEgu5SsQtAFLIuuLw22Zthedlo5eAI71nilwTURE4pWvQLAJeG949tC1QLe7HwQeB24ys2Q4SHxTuK2o9A8Msb+zD1CLQERKTyxJ58zsa8DrgXlm1kpwJlAVgLv/K/AY8BZgH9AH/E64r9PM/gbYFj7UJ919tEHngnips4/BoWBu585eBQIRKS2xBAJ3v2OM/Q78UYZ99wP3x1GPXGnu6Ble7lKLQERKzJQZLC6k1PgAQKfGCESkxEzJ+QjyraWjh/rZ0zl1ZlBjBCJSctQiGIfmjh5W1ddQV5PQGIGIlBwFgjG4O80dvaysn0WyOqEWgYiUHAWCMXT29tN98gyr6mdRV6NAICKlR4FgDC1HgoHilfU11FZX6YIyESk5CgRjaAlPHV01bxZ16hoSkRKkQDCG5o5eEtMqWJScSbImQV//oBLPiUhJUSAYQ0tHDyvm1lBZYSSrE4DSTIhIaVEgGENzRy+r5tcAUFdTBSjxnIiUFgWCUfQPDPFSZx8r580CUItAREqSAsEoUsnmVtanWgRBINBFZSJSShQIRpFKNreqPmgR1KpFICIlSIFgFKlkc6kWQW21xghEpPQoEIyiuaOH+bOnM3tGEACqKiu4YMY0tQhEpKQoEIyipaNnuDWQklTiOREpMbEEAjO72cz2mNk+M7snzf7Pmtn28Pa8mXVF9g1G9m2Koz5xSCWbS40PpCjxnIiUmqznIzCzSuBzwAagFdhmZpvcfVeqjLv/aaT8fwZeEXmIk+6+Ltt6xC2VbG7liEBQV5Pg8IlTBaqViEj84mgRrAf2uXuLu/cDDwMbRyl/B/C1GJ43p6LJ5qKUeE5ESk0cgWARcCCy3hpuO4+ZLQNWAD+IbJ5hZo1mttXMbs30JGZ2V1iusaOjI4Zqj675cHDq6MUjWwTVGiMQkdKS78Hi24FvuHs0a9syd28A3gX8g5mtSnegu9/n7g3u3lBfX5/zirYcCZLNXVQ785ztyZoEJ88o8ZyIlI44AkEbsCSyvjjcls7tjOgWcve28L4F+BHnjh8UTPPhHlbOC5LNRaWuLtaAsYiUijgCwTZgtZmtMLMEwZf9eWf/mNllQBJ4MrItaWbTw+V5wKuBXSOPLYSWI73njQ8AJMOLytQ9JCKlIutA4O4DwN3A48Bu4FF3f87MPmlmt0SK3g487O4e2bYGaDSzHcAPgXujZxsVyshkc1GpxHNdfRowFpHSkPXpowDu/hjw2IhtHx+x/ok0x/0cuDyOOsTppc5eBod8OP10lBLPiUip0ZXFaTSncgylaREo8ZyIlBoFgjRSWUfTjRHUaoxAREqMAkEaLR295ySbi0olntMYgYiUCgWCNJrTJJuLqlPiOREpIQoEI7g7LWmSzUXVKvGciJQQBYIRMiWbi6qrUSAQkdKhQDBC6oyhVaN0DSWrE0o8JyIlQ4FghJYR8xSnk6yu0hiBiJQMBYIRmjt6mJ4m2VyUEs+JSClRIBihpaOXFWmSzUUp8ZyIlBIFghEyJZuLSuUbUveQiJQCBYKIVLK50cYH4GwGUg0Yi0gpUCCISCWbG6tFoK4hESklCgQR+w6nTh0do0WgQCAiJUSBIKLlSHDq6Ip5o7cIamcq8ZyIlA4Fgojmw5mTzUVNCxPPHVMgEJESEEsgMLObzWyPme0zs3vS7H+fmXWY2fbw9oHIvjvNbG94uzOO+kxWy5GeMbuFUoI0ExosFpGpL+sZysysEvgcsAFoBbaZ2aY0U04+4u53jzi2DvhroAFw4Onw2GPZ1muiUsnm3nrFwnGVV+I5ESkVcbQI1gP73L3F3fuBh4GN4zz2TcBmd+8Mv/w3AzfHUKcJOxomm5tIi0BjBCJSCuIIBIuAA5H11nDbSP/JzJrM7BtmtmSCx2Jmd5lZo5k1dnR0xFDtc7Wkpqcc49TRlGR1QpPTiEhJyNdg8f8Blrv7FQS/+h+Y6AO4+33u3uDuDfX19bFXsHkcyeai6mqUeE5ESkMcgaANWBJZXxxuG+buR939dLj6BeDq8R6bLy3jSDYXVVsdJJ472a/EcyIytcURCLYBq81shZklgNuBTdECZhYdgb0F2B0uPw7cZGZJM0sCN4Xb8m48yeaidHWxiJSKrM8acvcBM7ub4Au8Erjf3Z8zs08Cje6+CfhjM7sFGAA6gfeFx3aa2d8QBBOAT7p7Z7Z1mozmjh5edtGccZdPJZ471tc/7laEiEgxyjoQALj7Y8BjI7Z9PLL8EeAjGY69H7g/jnpM1umBQQ4cO8lvXnnRuI9R4jkRKRW6shh46WjfuJLNRaW6hjrVNSQiU5wCAdF5isd3xhCcTTzXpUAgIlOcAgFnTx0dK9lclBLPiUipUCAgOGNowQVjJ5uLUuI5ESkVCgQEyeZWzht/t1BKXU2CTl1dLCJTXNkHAnen+XAPq+aPv1soJVmT0BiBiEx5ZR8Ijvb2c/zUwKRaBMlqJZ4Tkamv7ANB8+FgoHgip46mJKsTGiMQkSmv7ANBy5GJnzqaUldTpclpRGTKUyAIk80tmkSaiGSNEs+JyNRX9oGgOUw2VzHOZHNR0XxDIiJTVdkHgpaO8c9TPFIqEGjAWESmsrIOBKcHBnmps29SA8VwNt+QZioTkamsrAPBS0f7GPLJDRTD2QykSjwnIlNZWQeCVI6hybYIUonndAqpiExlsQQCM7vZzPaY2T4zuyfN/g+Z2a5w8vonzGxZZN+gmW0Pb5tGHptLzcMT1k+uRZBKPKfBYhGZyrKemMbMKoHPARuAVmCbmW1y912RYr8EGty9z8w+CPx34J3hvpPuvi7bekxGKtncrOmTexmUeE5ESkEcLYL1wD53b3H3fuBhYGO0gLv/0N37wtWtBJPUF1xzx+SSzUUVe+K5PYdO0NZ1stDVEJEiFkcgWAQciKy3htsyeT/w3cj6DDNrNLOtZnZrpoPM7K6wXGNHR0dWFYYg2VxLx+SSzUUla4o7zcT7H9jG3V99ptDVEJEiltfBYjN7D9AA/F1k8zJ3bwDeBfyDma1Kd6y73+fuDe7eUF9fn3VdjvRMPtlcVF11omjHCDpOnKb12El++VIXO9u6C10dESlScQSCNmBJZH1xuO0cZnYj8FHgFnc/ndru7m3hfQvwI+AVMdRpTC3hGUOr5mcXCGqLOPHcs21dw8sPPbW/cBURkaIWRyDYBqw2sxVmlgBuB845+8fMXgH8G0EQOBzZnjSz6eHyPODVQHSQOWdSyeZWTmB6ynTqaqqK9jqCptZuzOA3rljIt375a46fKt6xDBEpnKwDgbsPAHcDjwO7gUfd/Tkz+6SZ3RIW+ztgFvD1EaeJrgEazWwH8EPg3hFnG+VM8+HJJ5uLStYkOHVmqCgTzzW1dnNx/Sx+/7UrOXlmkG8+c15DTUQk+9NHAdz9MeCxEds+Hlm+McNxPwcuj6MOE9VyZPLJ5qKiiedmJrILKnFyd5pau3ntJfO4YnEtVyyew4Nb9/Pe65Zhlt3fLCKlpWyvLG7OItlcVLEmnjvYfYojPae5cnEtAO955TL2Hu7hFy90FrZiIlJ0yjIQnB4Y5EBnH6smmVoiKpV4rtjOHGpqDc4SunzxHAB+88qLuGDGNB586qVCVktEilBZBoL9YbK5yaaWiKqrSaWZKK6B2KbWLqZVGGsXXgDAzEQlt129hO/tPEjHidNjHC0i5aQsA8HwqaMxBILa6uJMPNfU2s2lF85mRlXl8LZ3X7uUM4POo40HRjlSRMpNWQaCVLK5FTF0DaUSzxXTGEEwUNzFFWG3UMqq+lm8atVcvvrUSwwOeYFqJyLFpkwDQU9WyeaiplVWMGdmFV1FNEaw/2gfx08NcEU4UBz1nmuX0dZ1kh/tOXz+gSJSlsoyELR09MbSLZSSrK4qqsRzTWE6icsXzTlv34a1C5g/ezoPbtWVxiISKLtA4O5B1tEYuoVSii3xXNOBLhLTKrj0wtnn7auqrOD2a5bwo+c7ONDZl+ZoESk3ZRcIjvT0c+LUQKwtgrrqRFGNETS1dbN24QVUVaZ/e29fvxQDvvoLnUoqImUYCFqGp6eMsWuoJlE0YwSDQ87Otm6uXHx+t1DKRbUzuWHNAh7ddoDTA8WXGkNE8qvsAsHw9JRZJpuLCsYIiiMQtHT00Nc/yOVpBoqjfvvaZRzt7ed7Ow/lp2IiUrTKLhC0dMSTbC6qmBLP7QivKB6tRQBw/cXzWDa3moe2qntIpNyVXSBo7uiJJdlcVF118aSZaGrtojpROWbXV0WF8e5XLuUXL3byq0PHY6/Hj/Yc5h3/9qROUxWZAsouELQc6c16MpqRaoso8VxTazcvXzSHynEEut+6egmJaRWxtwqebz/BHz30DE/vP8b7vrSNP3zoaQ52a95kkWJVVoFgONlcjOMDUDyJ5/oHhth18PiY3UIpyZoEb718Id/8ZRu9pwdiqcOx3n4+8EAjMxPT+MGfvY4P33QJT+w+zA3/88fc95NmzgwOxfI8IhKfsgoEcSabiyqWxHPPt5+gf2BozIHiqHdfu4ye0wN8a3v2k9acGRziDx96hkPdp7jvvVezbG4Nd79xNVs+9DquWzmXv33sV/zGP/1UqbBFikwsgcDMbjazPWa2z8zuSbN/upk9Eu5/ysyWR/Z9JNy+x8zeFEd9Mokz2VxUsSSeaxrnQHHUVUtrWbPwAh7c+hLu2eUf+tT/3cWTLUf527dfzlVLk8Pbl9RV88X3XcPn39tA7+lB3vFvT/Jnj+7gSE/8WVDdnReP9NJ6rI8h5VMSGZesk+2YWSXwOWAD0ApsM7NNI6acfD9wzN0vNrPbgc8A7zSztQRzHL8MuAjYYmaXuHtOTr+JM9lcVLEknnu2rYs5M6tYWlc97mPMjPdcu5SPfnMnz7zUxdXLkmMflMZXn3qJB57cz++9ZgW3Xb04bZkNaxfw6ovn8s8/2Mfnf9rC5l2H+PObL+OO9UvHNaaRyZnBIRpfPMaW3e1s2d3O/qPBFdMzqipYPreGVfWzWFlfE9zmBcuzZ1RN+vkyGRgc4vTAEDOqKrP6e0TyLY6pKtcD+9y9BcDMHgY2cu4k9BuBT4TL3wD+2YL5EjcCD7v7aeAFM9sXPt6TMdTrPM0dPVx4wYxYks1FpRLPFXqMYMeBbq5YPGfCU1Heum4R/+2xX/HQ1v2TCgRPtRzl49/eyesuqeeeN68ZtWx1Yhp/fvNlvP2qRfzVt57jY9/aydcbD/CpWy8fnkRnPI6fOsOP93SwZXc7P/zVYY6fGiBRWcGrLp7LB65fgZnxwpFeWjp62Pnrbr678yDRBkL97OmsnFfDyvpZrIoEicXJmUyrrODM4BDH+vrp6jtDZ28/XX39dPae4VhfP8d6+znWFy5H1rtPnu0aTFRWMKOqgpmJSmZUVTKzKnqfeXtFhTGtwqgwo7IicjOjIryPbj9bLnjeoSFwYMgd96CFlFofSq07OM7QUFgu8roawY+D4D7cZmAY0Y/VyDKpxwZwjzw/5z5nalt0//BBqcXzN519bKLbIssjypGxXOZWYvAXRf/GjEXP+x+zc/Zl2m5py6SvS2a3XLmIOdXx/pCJ4xtxERBNcN8KvDJTGXcfMLNuYG64feuIYxelexIzuwu4C2Dp0qWTqujMqkquXj65X7xjqatJFHSM4NSZQZ5vP8Fdl66c8LE106fx9qsW8fC2A3zsrWuHB7/H40BnHx986BmWzq3mn+54xbh/CV88fzZf/b1XsmnHr/nUd3Zzy+f+H+955TI+/KZLmTMz/Yf8QGcfT+xuZ8vuw2xtOcrAkJOsrmLD2gvZsHY+16+uzxjkTw8M8tLRPpo7emk50kNLRxAkvrvzIF19536BT59WwYlRBs9nVlWSrK4iWZMgWZ1gcbI6WK9OMDNRyekzQ5w8M8ip8HbyzCAn+wc5NTDEqf5BjvT0n7u/PyijniwZj+tWzSvKQJAX7n4fcB9AQ0PDpP5lPv22y2OtU1RtdVVBxwh2HTzOwJCnTT09Hu+5dhlfeXI/X288wO+/btW4juk9PcDvfaWRM4NDfOG9DRm/wDMxMzauW8QbLpvP33//eb7y5It8d+dB/vIta3jbKxbhDs+2dbNldzubd7Xzq0MnAFhVX8P7r1/BjWsXcNXS5LiCz/RplaxeMJvVC85PxNfZ209LRxAcmo/0cPrMEMnqBHU1VdRWJ6irSVBbXUVd+MUfnewnLu7OmUFnyJ2BIWdwyBkacgY9uB/e5sH9YLgvKAeD7sO/0CvCn5sVZsPrFRb+sg9/yQfb7Jxf/alfzqlf72eXz/1FHiz62fJA8Bacfb5UXVItiZHPHewD7Owv8XS/pM/5FT28LVru/IPG+zjnvP4j10e0LDK1REbujLY40rVY0j32WHUZqXaC/2fjEUcgaAOWRNYXh9vSlWk1s2nAHODoOI+dEuqqExzsPlWw52860AVw3mQ043XJgtmsX17HV3/xEr/3mpVjXnA3NOR86NHtPN9+gi/9zvqszsS6YEYVn7jlZdx29WI+9q2dfOjRHdz/sxc4fPw0h0+cpsKgYXkdH33LGm5YMz8HZ30lqKupo2F5XayPOxFmRmKaxhWkMOIIBNuA1Wa2guBL/HbgXSPKbALuJOj7vw34gbu7mW0Cvmpmf08wWLwa+EUMdcq7ZE2C3Qfjv0J3vJraupk3azoL58yY9GO8+9ql/MnD2/npviO87pL6Ucv+4xN7efy5dj72G2vGLDteL180h//9wVfxSOMB7v9/L9CwPMmNaxbwhkvnk5xAd5WITEzWgSDs878beByoBO539+fM7JNAo7tvAr4I/Hs4GNxJECwIyz1KMLA8APxRrs4YyrVCJ55rag0yjk50oDjq5pdfyNyaBA9u3T/ql/t3mg7yj0/s5barF/P+61dM+vnSqagw7li/lDvWT24cSEQmLpYxAnd/DHhsxLaPR5ZPAb+V4dhPA5+Oox6FFE08NzMRfx/yaHpOD9Dc0cNbr1iY1eNMn1bJO65Zwr/9uJlfd53kojSJ+Xa2dfNnX9/OVUtr+fTbXp5V4BGR4lBWVxbnUirxXCFaBTvbunGHKyc5UBz1rvVLceDhNJPWdJw4zV1faSRZneBff/tqpk/Lb8ATkdxQIIhJqg+7EGcOPRteUTyR8/AzWVJXzesvqefhbQfOyQvUPzDEBx98ms6+fj7/3gbmz578WISIFBcFgpgkC5iKekdrF4tqZzJv1vRYHu+3r1vG4ROn2byrHQhOd/urb+2kcf8x/u62K3n5ouwDjogUDwWCmKQSzxUizcSzbd1cHuOX8+sumc+i2pk8uHU/AF/++Ys80niAu99wMb955UWxPY+IFAcFgpikWgRdeb66uKuvn/1H+7hiSXyBoLLCeNcrl/Lz5qM88PMX+dR3drNh7QI+tOGS2J5DRIqHAkFM5hQo8Vwq4+gVi2pjfdx3XrOEqkrjrzc9x8X1s/jsO9fFOqubiBQPBYKYFCrx3LNt8Q0UR82bNZ1b1y1ibk2CL9zZEHuiPhEpHvrvjlFdTSLvLYIdB7pYMa9mwnl+xuNv3345/QND1CgIiJQ0tQhilKyuyvsYQdwDxVFVlRUKAiJlQIEgRsnq/LYIDp84xcHuU5NONCciAgoEsUrWJPI6RpC6kGyyqadFRECBIFZ1eQ4EO1q7qTB42UUX5O05RaT0KBDEqLa6ajjxXD4829rFxfNnqR9fRLKiQBCjfCaec3eaWrvVLSQiWVMgiFE+E8+1dZ3kaG+/BopFJGsKBDHKZ+I5DRSLSFyyCgRmVmdmm81sb3ifTFNmnZk9aWbPmVmTmb0zsu/LZvaCmW0Pb+uyqU+h5TPx3I7WbqoqjTULz5+MXURkIrJtEdwDPOHuq4EnwvWR+oD3uvvLgJuBfzCz2sj+/+ru68Lb9izrU1DDLYI8BIJn27q49MLZmhxGRLKWbSDYCDwQLj8A3DqygLs/7+57w+VfA4eBeGY7LzJzZlZhBsdyfHXx0JAGikUkPtkGggXufjBcPgQsGK2wma0HEkBzZPOnwy6jz5pZxplVzOwuM2s0s8aOjo4sq50b0yoruGBG7hPP7e/s48SpAa7QBDEiEoMxA4GZbTGznWluG6Pl3N0BH+VxFgL/DvyOu6fmQPwIcBlwDVAH/EWm4939PndvcPeG+vribVDkI/FcU2sXoIFiEYnHmFciufuNmfaZWbuZLXT3g+EX/eEM5S4AvgN81N23Rh471Zo4bWZfAj48odoXoWR17lsETa3dTJ9WweoFs3L6PCJSHrLtGtoE3Bku3wl8e2QBM0sA3wS+4u7fGLFvYXhvBOMLO7OsT8ElqxMc683tGEFTaxcvu+gCqip19q+IZC/bb5J7gQ1mthe4MVzHzBrM7AthmXcArwXel+Y00YfM7FngWWAe8Kks61NwuU48NzA4xM624+oWEpHYZJWkxt2PAjek2d4IfCBcfhB4MMPxb8zm+YtRrscImjt6OXlmUFcUi0hs1LcQs2R1gtMDuUs8t2N4oFiBQETioUAQs2R1eHVxjrqHnm3tZtb0aaycp4FiEYmHAkHMcp14rqm1i5cvuoCKCsvJ44tI+VEgiFldGAhyMU7QPzDE7oMnNFAsIrFSIIhZqmsoF2cO7Tl0gv7BIY0PiEisFAhilsvEc01tXQBcsag29scWkfKlQBCzVOK5zhwknms60E1tdRVL6mbG/tgiUr4UCGI2rbKCOTOr6MpB19CO1i4uXzSH4EJsEZF4KBDkQLI6/ovKTvYPsvdwD1dqoFhEYqZAkAO5SDy362A3g0PO5RooFpGYKRDkQJBmIt4xgqZwjmK1CEQkbgoEOVBbnYh9jKCptZv5s6dz4ZwZsT6uiIgCQQ6kEs8Fc/XEo6m1S9cPiEhOKBDkwHDiuTPxJJ47ceoMLUd6dUWxiOSEAkEOnL26OJ5xgp1tx3FHA8UikhNZBQIzqzOzzWa2N7xPZig3GJmUZlNk+woze8rM9pnZI+FsZlNe3Innhuco1mT1IpID2bYI7gGecPfVwBPhejon3X1deLslsv0zwGfd/WLgGPD+LOtTFOJOPNfU2s2i2pnMnTU9lscTEYnKNhBsBB4Ilx8gmHd4XMJ5it8IpOYxntDxxWw431BMZw41tXVx5RK1BkQkN7INBAvc/WC4fAhYkKHcDDNrNLOtZnZruG0u0OXuA+F6K7Ao0xOZ2V3hYzR2dHRkWe3cGh4jiKFF0H78FAc6T2qgWERyZsw5i81sC3Bhml0fja64u5tZpvMll7l7m5mtBH4QTljfPZGKuvt9wH0ADQ0N8Z2XmQNxJp7bsrsdgDdcOj/rxxIRSWfMQODuN2baZ2btZrbQ3Q+a2ULgcIbHaAvvW8zsR8ArgP8Aas1sWtgqWAy0TeJvKDqpxHNxtAi27GpnaV01lyzQ1JQikhvZdg1tAu4Ml+8Evj2ygJklzWx6uDwPeDWwy4OrrX4I3Dba8VNVsjqR9RhB7+kBftZ8lBvXLFDGURHJmWwDwb3ABjPbC9wYrmNmDWb2hbDMGqDRzHYQfPHf6+67wn1/AXzIzPYRjBl8Mcv6FI04Es/95PkO+geG2LA209CLiEj2xuwaGo27HwVuSLO9EfhAuPxz4PIMx7cA67OpQ7Gqq0nQ1nUqq8fYvKud2uoqrlme9vIMEZFY6MriHElWJ7IaIxgYHOIHew7zxkvnM61Sb5OI5I6+YXIkWROMEUw28Vzj/mN09Z1Rt5CI5JwCQY5km3hu8652EpUVvPaS+phrJiJyLgWCHKmrCS4qm0yaCXdn8652XnXxXGqmZzWMIyIyJgWCHKkN00x0TeKisufbe3ips0/dQiKSFwoEOZJN4rnNuw4BcOMaBQIRyT0FghzJJvHc5l3tXLmklgUXaFpKEck9BYIcmWyLoP34KXa0dnOTuoVEJE8UCHIklXhuorOUpZLMaXxARPJFgSBHKitsUonnNodJ5lbPV5I5EckPBYIcqqtO0DmBMYKe0wP8fN9RNqxVkjkRyR8Fghyqra6iawKB4CfPd9A/qCRzIpJfCgQ5VFeToLN3/GMEW8Ikcw3LlGRORPJHgSCHJpJ4bjjJ3GVKMici+aVvnBxK1gRjBONJPLftxSDJnE4bFZF8UyDIoWR1gv5xJp7bvKudxLQKXrNaSeZEJL+yCgRmVmdmm81sb3h/Xue2mb3BzLZHbqfM7NZw35fN7IXIvnXZ1KfYjDfxnLuzefchXr1KSeZEJP+ybRHcAzzh7quBJ8L1c7j7D919nbuvA94I9AHfjxT5r6n97r49y/oUleE0E2MMGO9pP8GBzpNsWHthPqolInKObAPBRuCBcPkB4NYxyt8GfNfd+7J83ikhWTO+fENbdgVXE9+4Zn7O6yQiMlK2gWCBux8Mlw8BY4103g58bcS2T5tZk5l91symZzrQzO4ys0Yza+zo6Miiyvkz3sRzm3e1s25JLfOVZE5ECmDMQGBmW8xsZ5rbxmg5D06NyXh6jJktJJjE/vHI5o8AlwHXAHXAX2Q63t3vc/cGd2+or58aA6rjSTyXSjKni8hEpFDGHJl09xsz7TOzdjNb6O4Hwy/6w6M81DuAb7r7cId5pDVx2sy+BHx4nPWeEoYTz40SCDbvUpI5ESmsbLuGNgF3hst3At8epewdjOgWCoMHFiTWuRXYmWV9ispw4rlRMpBu3tXOsrlKMicihZNtILgX2GBme4Ebw3XMrMHMvpAqZGbLgSXAj0cc/5CZPQs8C8wDPpVlfYrOaInnek4P8GTzUTasUZI5ESmcrE5ad/ejwA1ptjcCH4isvwgsSlPujdk8/1SQrMmcZkJJ5kSkGOjK4hxLVmfuGtq8q51kdRVXK8mciBSQAkGOZUo8d2ZwiB/86jBvvGyBksyJSEHpGyjH6jIkntv2YifdJ8+wYa0uIhORwlIgyLHaDInnlGRORIqFAkGOpUs85+5s2d3O9RfPU5I5ESk4BYIcS5d47mySOZ0tJCKFp0CQY8NpJiLXEmx+rh0zuEFJ5kSkCCgQ5Fht2CKITmK/eXeYZG62ksyJSOEpEOTYyMRzh7pP0aQkcyJSRBQIcmxk4rnNu8Mkc2sUCESkOCgQ5NjIxHNbdrWzfG41FyvJnIgUCQWCPEglnhtOMrdWSeZEpHgoEORBKvHcj/ekksxpbmIRKR4KBHmQrK6is7efzbsOUVeTUJI5ESkqCgR5kKxOcKTndJhkbj6VFeoWEpHiofwGeVBXk+BIT3DW0I06W0hEikxWLQIz+y0ze87MhsysYZRyN5vZHjPbZ2b3RLavMLOnwu2PmFkim/oUq2R4LcH0aRW89pJ5Ba6NiMi5su0a2gm8HfhJpgJmVgl8DngzsBa4w8zWhrs/A3zW3S8GjgHvz7I+RSlZHSSeu/7ieVQn1AgTkeKSVSBw993uvmeMYuuBfe7e4u79wMPAxnDC+jcC3wjLPUAwgX3JSSWe09XEIlKM8jFYvAg4EFlvDbfNBbrcfWDE9rTM7C4zazSzxo6OjpxVNheuWzWXD1y/grdeeVGhqyIicp4x+ynMbAuQ7sT3j7r7t+OvUnrufh9wH0BDQ4OPUbyozJ5RxcfeunbsgiIiBTBmIHD3G7N8jjZgSWR9cbjtKFBrZtPCVkFqu4iI5FE+uoa2AavDM4QSwO3AJg8m8f0hcFtY7k4gby0MEREJZHv66NvMrBW4DviOmT0ebr/IzB4DCH/t3w08DuwGHnX358KH+AvgQ2a2j2DM4IvZ1EdERCbOgh/mU0tDQ4M3NjYWuhoiIlOKmT3t7udd86UUEyIiZU6BQESkzCkQiIiUOQUCEZEyNyUHi82sA9g/ycPnAUdirE5cVK+JUb0mRvWamFKt1zJ3rx+5cUoGgmyYWWO6UfNCU70mRvWaGNVrYsqtXuoaEhEpcwoEIiJlrhwDwX2FrkAGqtfEqF4To3pNTFnVq+zGCERE5Fzl2CIQEZEIBQIRkTJXsoHAzG42sz1mts/M7kmzf7qZPRLuf8rMluehTkvM7IdmtsvMnjOzP0lT5vVm1m1m28Pbx3Ndr/B5XzSzZ8PnPC+jnwX+KXy9mszsqjzU6dLI67DdzI6b2X8ZUSYvr5eZ3W9mh81sZ2RbnZltNrO94X0yw7F3hmX2mtmdeajX35nZr8L36ZtmVpvh2FHf8xzU6xNm1hZ5r96S4dhR/3dzUK9HInV60cy2Zzg2l69X2u+GvH3G3L3kbkAl0AysBBLADmDtiDJ/CPxruHw78Ege6rUQuCpcng08n6Zerwf+bwFesxeBeaPsfwvwXcCAa4GnCvCeHiK4ICbvrxfwWuAqYGdk238H7gmX7wE+k+a4OqAlvE+Gy8kc1+smYFq4/Jl09RrPe56Den0C+PA43udR/3fjrteI/f8T+HgBXq+03w35+oyVaotgPbDP3VvcvR94GNg4osxG4IFw+RvADWZmuayUux9092fC5RME8zNknKe5yGwEvuKBrQSzyy3M4/PfADS7+2SvKM+Ku/8E6ByxOfoZegC4Nc2hbwI2u3unux8DNgM357Je7v59PzsX+FaC2f/yKsPrNR7j+d/NSb3C//93AF+L6/nGa5Tvhrx8xko1ECwCDkTWWzn/C3e4TPhP000wOU5ehF1RrwCeSrP7OjPbYWbfNbOX5alKDnzfzJ42s7vS7B/Pa5pLt5P5H7QQrxfAAnc/GC4fAhakKVPo1+13CVpy6Yz1nufC3WGX1f0ZujkK+Xq9Bmh3970Z9ufl9Rrx3ZCXz1ipBoKiZmazgP8A/ou7Hx+x+xmC7o8rgf8FfCtP1bre3a8C3gz8kZm9Nk/POyYLpji9Bfh6mt2Fer3O4UEbvajOxTazjwIDwEMZiuT7Pf8XYBWwDjhI0A1TTO5g9NZAzl+v0b4bcvkZK9VA0AYsiawvDrelLWNm04A5wNFcV8zMqgje6Ifc/X+P3O/ux929J1x+DKgys3m5rpe7t4X3h4FvEjTRo8bzmubKm4Fn3L195I5CvV6h9lT3WHh/OE2ZgrxuZvY+4K3Au8MvkPOM4z2Plbu3u/uguw8Bn8/wfIV6vaYBbwceyVQm169Xhu+GvHzGSjUQbANWm9mK8Nfk7cCmEWU2AanR9duAH2T6h4lL2Af5RWC3u/99hjIXpsYqzGw9wXuU0wBlZjVmNju1TDDYuHNEsU3Aey1wLdAdabLmWsZfaoV4vSKin6E7gW+nKfM4cJOZJcOukJvCbTljZjcDfw7c4u59GcqM5z2Pu17RMaW3ZXi+8fzv5sKNwK/cvTXdzly/XqN8N+TnM5aLEfBiuBGc5fI8wRkIHw23fZLgnwNgBkFXwz7gF8DKPNTpeoKmXROwPby9BfgD4A/CMncDzxGcLbEVeFUe6rUyfL4d4XOnXq9ovQz4XPh6Pgs05Ol9rCH4Yp8T2Zb314sgEB0EzhD0wb6fYEzpCWAvsAWoC8s2AF+IHPu74edsH/A7eajXPoI+49RnLHV23EXAY6O95zmu17+Hn50mgi+4hSPrFa6f97+by3qF27+c+kxFyubz9cr03ZCXz5hSTIiIlLlS7RoSEZFxUiAQESlzCgQiImVOgUBEpMwpEIiIlDkFAik7ZtYT3i83s3fF/Nh/OWL953E+vkguKBBIOVsOTCgQhFegjuacQODur5pgnUTyToFAytm9wGvC/PJ/amaVFuTy3xYmRvt9GJ7z4KdmtgnYFW77Vph87LlUAjIzuxeYGT7eQ+G2VOvDwsfeaUFO+3dGHvtHZvYNC+YQeChypfS9FuSnbzKz/5H3V0fKxli/bkRK2T0E+fHfChB+oXe7+zVmNh34mZl9Pyx7FfByd38hXP9dd+80s5nANjP7D3e/x8zudvd1aZ7r7QTJ1q4E5oXH/CTc9wrgZcCvgZ8Brzaz3QRpGC5zd7cMk8uIxEEtApGzbiLIp7SdIAXwXGB1uO8XkSAA8MdmlkprsSRSLpPrga95kHStHfgxcE3ksVs9SMa2naDLqhs4BXzRzN4OpM0ZJBIHBQKRswz4z+6+LrytcPdUi6B3uJDZ6wmSlF3nQfrrXxLkrpqs05HlQYLZxQYIslt+gyCL6PeyeHyRUSkQSDk7QTAtYMrjwAfDdMCY2SVhpsmR5gDH3L3PzC4jmLoz5Uzq+BF+CrwzHIeoJ5gy8ReZKhbmpZ/jQWrtPyXoUhLJCY0RSDlrAgbDLp4vA/9I0C3zTDhg20H6qQG/B/xB2I+/h6B7KOU+oMnMnnH3d0e2fxO4jiB7pQN/7u6HwkCSzmzg22Y2g6Cl8qFJ/YUi46DsoyIiZU5dQyIiZU6BQESkzCkQiIiUOQUCEZEyp0AgIlLmFAhERMqcAoGISJn7/3T2Kl4nnmDLAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "print(\"Energy:\")\n",
    "plt.plot([evaluation.eigenvalue for evaluation in results.history])\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.show()\n",
    "\n",
    "print(\"Schmidt Coefficients:\")\n",
    "plt.plot([abs(evaluation.eigenstate) for evaluation in results.history])\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.yscale(\"log\")\n",
    "plt.show()\n",
    "\n",
    "print(\"Parameters:\")\n",
    "plt.plot([evaluation.parameters for evaluation in results.history])\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "807204bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.23.2</td></tr><tr><td><code>qiskit-aer</code></td><td>0.11.2</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.20.1</td></tr><tr><td><code>qiskit</code></td><td>0.39.5</td></tr><tr><td><code>qiskit-nature</code></td><td>0.5.2</td></tr><tr><td><code>qiskit-finance</code></td><td>0.3.4</td></tr><tr><td><code>qiskit-optimization</code></td><td>0.5.0</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.5.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.9.13</td></tr><tr><td>Python compiler</td><td>Clang 12.0.0 </td></tr><tr><td>Python build</td><td>main, Aug 25 2022 18:29:29</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Thu Mar 02 10:08:05 2023 +08</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "\n",
    "%qiskit_version_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "818d68b2",
   "metadata": {},
   "source": [
    "### This code is a Qiskit project.\n",
    "\n",
    "© Copyright IBM 2022.\n",
    "\n",
    "This code is licensed under the Apache License, Version 2.0. You may\n",
    "obtain a copy of this license in the LICENSE.txt file in the root directory\n",
    "of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n",
    "\n",
    "Any modifications or derivative works of this code must retain this\n",
    "copyright notice, and modified files need to carry a notice indicating\n",
    "that they have been altered from the originals."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}