From 633fb873b03b16a5d4f7c98dd63cf217f03801e2 Mon Sep 17 00:00:00 2001
From: Julien Gacon <gaconju@gmail.com>
Date: Thu, 1 Apr 2021 17:39:08 +0200
Subject: [PATCH] add missing algos

---
 .../Qiskit Algorithms Transition Guide.ipynb  | 1720 -----------------
 1 file changed, 1720 deletions(-)
 delete mode 100644 MigrationGuide/Qiskit Algorithms Transition Guide.ipynb

diff --git a/MigrationGuide/Qiskit Algorithms Transition Guide.ipynb b/MigrationGuide/Qiskit Algorithms Transition Guide.ipynb
deleted file mode 100644
index 3b8fe32..0000000
--- a/MigrationGuide/Qiskit Algorithms Transition Guide.ipynb	
+++ /dev/null
@@ -1,1720 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# Qiskit Algorithms Transition Guide\n",
-    "\n",
-    "**Restructuring the applications**\n",
-    "\n",
-    "The Qiskit 0.25.0 release includes a restructuring of the algorithms. What previously has been referred to as Qiskit Aqua, the single application module of Qiskit, is now split into dedicated application modules for Optimization, Finance, Machine Learning and Nature (including Physics & Chemistry).\n",
-    "\n",
-    "**Algorithm interfaces**\n",
-    "\n",
-    "Additionally to the restructuring, all algorithms follow a new unified paradigm: algorithms are classified according to the problems they solve, and within one application class algorithms can be used interchangeably to solve the same problem. This means that, unlike before, algorithm instances are decoupled from the problem they solve. We can summarize this in a flowchart:\n",
-    "\n",
-    "<img src=\"algorithmflow.png\" alt=\"Drawing\" style=\"width: 1000px;\"/>\n",
-    "\n",
-    "For example, the variational quantum eigensolver, `VQE` is a `MinimumEigensolver` as it computes the minimum eigenvalue of an operator. The problem here is specified with the operator, whose eigenvalue we seek, while properties such as the variational ansatz circuit and classical optimizer are properties of the algorithm. That means the `VQE` has the following structure\n",
-    "```python\n",
-    "vqe = VQE(ansatz, optimizer)\n",
-    "result = vqe.compute_minimum_eigenvalue(operator)\n",
-    "```\n",
-    "We can exchange the `VQE` with any other algorithm that implements the `MinimumEigensolver` interface to compute the eigenvalues of your operator, e.g.\n",
-    "```\n",
-    "numpy_based = NumPyMinimumEigensolver()\n",
-    "classical_reference = numpy_based.compute_minimum_eigenvalue(operator)\n",
-    "```\n",
-    "This allows you to easily switch between different algorithms, check against classical references, and provide your own implementation -- you just have to implement the existing interface."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This notebook serves as migration guide to facilitate changing your current code using Qiskit Aqua to the new structure.\n",
-    "\n",
-    "## Contents\n",
-    "\n",
-    "1. [Quantum Instance](#qi)\n",
-    "1. [Operators](#h)\n",
-    "1. [Optimizers](#opt)\n",
-    "1. [Grover](#grover)\n",
-    "1. [Amplitude estimation](#ae)\n",
-    "1. [Minimum eigenvalues](#mes)\n",
-    "    1. [NumPy minimum eigensolver](#npmes)\n",
-    "    1. [VQE](#vqe)\n",
-    "    1. [QAOA](#qaoa) \n",
-    "1. [(General) Eigenvalues](#es)\n",
-    "1. [Shor](#shor)\n",
-    "1. [HHL](#hhl)\n",
-    "1. [Phase Estimation](#pe)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We're disabling deprecation warning for this notebook so you won't see any when we instantiate an object from `qiskit.aqua`. Note though, that the entire package is deprecated and will emit a warning like the following:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jul/Qiskit/qiskit-aqua/qiskit/aqua/components/optimizers/optimizer.py:50: DeprecationWarning: The package qiskit.aqua.components.optimizers is deprecated. It was moved/refactored to qiskit.algorithms.optimizers (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>\n",
-      "  'qiskit.algorithms.optimizers', 'qiskit-terra')\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.components.optimizers import COBYLA\n",
-    "\n",
-    "optimizer = COBYLA()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings\n",
-    "warnings.simplefilter('ignore', DeprecationWarning)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# QuantumInstance<a id='qi' href='#'></a>\n",
-    "\n",
-    "The `QuantumInstance` moved the import location from\n",
-    "```\n",
-    "qiskit.aqua.QuantumInstance\n",
-    "```\n",
-    "to \n",
-    "```\n",
-    "qiskit.utils.QuantumInstance\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import Aer\n",
-    "from qiskit.aqua import QuantumInstance as AquaQuantumInstance\n",
-    "\n",
-    "backend = Aer.get_backend('statevector_simulator')\n",
-    "aqua_qinstance = AquaQuantumInstance(backend, seed_simulator=2, seed_transpiler=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import Aer\n",
-    "from qiskit.utils import QuantumInstance\n",
-    "\n",
-    "backend = Aer.get_backend('statevector_simulator')\n",
-    "qinstance = QuantumInstance(backend, seed_simulator=2, seed_transpiler=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Operators<a id='h' href='#'></a>\n",
-    "\n",
-    "The Opflow operators moved from\n",
-    "```\n",
-    "qiskit.aqua.operators\n",
-    "```\n",
-    "to\n",
-    "```\n",
-    "qiskit.opflow\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.aqua.operators import X, I, Y\n",
-    "\n",
-    "op = (X ^ I) + (Y ^ 2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.opflow import X, I, Y\n",
-    "\n",
-    "op = (X ^ I) + (Y ^ 2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Additional features:**\n",
-    "\n",
-    "With `qiskit.opflow` we introduce a new, more efficient representation of sums of Pauli strings, which can significantly speed up computations on very large sums of Paulis. This efficient representation is automatically used if Pauli strings are summed:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "qiskit.opflow.primitive_ops.pauli_sum_op.PauliSumOp"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "op = (X ^ X ^ Y ^ Y) + (X ^ 4) + (Y ^ 4) + (I ^ X ^ I ^ I)\n",
-    "type(op)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Optimizers<a id='op' href='#'></a>\n",
-    "\n",
-    "The classical optimization routines changed locations from\n",
-    "```\n",
-    "qiskit.aqua.components.optimizers\n",
-    "```\n",
-    "to \n",
-    "```\n",
-    "qiskit.algorithms.optimizers\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.aqua.components.optimizers import SPSA\n",
-    "\n",
-    "spsa = SPSA(maxiter=10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.algorithms.optimizers import SPSA\n",
-    "\n",
-    "spsa = SPSA(maxiter=10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# Grover<a href='#' id='grover'></a>\n",
-    "\n",
-    "## Summary\n",
-    "\n",
-    "The previous structure\n",
-    "```python\n",
-    "grover = Grover(oracle_settings, algorithm_settings)\n",
-    "result = grover.run()\n",
-    "```\n",
-    "is changed to split problem/oracle settings and algorithm settings, to\n",
-    "```python\n",
-    "grover = Grover(algorithm_settings)\n",
-    "problem = AmplificationProblem(oracle_settings)\n",
-    "result = grover.amplify(problem)\n",
-    "```\n",
-    "<!-- See the documentation of the [deprecated Grover](https://qiskit.org/documentation/stubs/qiskit.aqua.algorithms.Grover.html#qiskit.aqua.algorithms.Grover) and [new Grover](#). -->"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Transition guide\n",
-    "\n",
-    "For oracles provided as circuits and a `is_good_state` function to determine good states"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.circuit import QuantumCircuit\n",
-    "\n",
-    "oracle = QuantumCircuit(2)\n",
-    "oracle.cz(0, 1)\n",
-    "\n",
-    "def is_good_state(bitstr):\n",
-    "    return sum(map(int, bitstr)) == 2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Top measurement: 11\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import Grover\n",
-    "\n",
-    "grover = Grover(oracle, is_good_state, quantum_instance=aqua_qinstance)\n",
-    "result = grover.run()\n",
-    "print('Top measurement:', result.top_measurement)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Top measurement: 11\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import Grover, AmplificationProblem\n",
-    "\n",
-    "problem = AmplificationProblem(oracle=oracle, is_good_state=is_good_state)\n",
-    "grover = Grover(quantum_instance=qinstance)\n",
-    "result = grover.amplify(problem)\n",
-    "print('Top measurement:', result.top_measurement)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since we are streamling all algorithms to use the `QuantumCircuit` class as base primitive, defining oracles using the `qiskit.aqua.compontents.Oracle` class is deprecated. Instead of using e.g. the `LogicalExpressionOracle` you can now use the `PhaseOracle` circuit from the circuit library."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Top measurement: 01\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.components.oracles import LogicalExpressionOracle\n",
-    "from qiskit.aqua.algorithms import Grover\n",
-    "\n",
-    "oracle = LogicalExpressionOracle('x & ~y')\n",
-    "grover = Grover(oracle, quantum_instance=aqua_qinstance)\n",
-    "result = grover.run()\n",
-    "print('Top measurement:', result.top_measurement)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Top measurement: 11\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.circuit.library import PhaseOracle\n",
-    "from qiskit.algorithms import Grover, AmplificationProblem\n",
-    "\n",
-    "oracle = PhaseOracle('x & ~y')\n",
-    "problem = AmplificationProblem(oracle=oracle, is_good_state=oracle.evaluate_bitstring)\n",
-    "grover = Grover(quantum_instance=qinstance)\n",
-    "result = grover.amplify(problem)\n",
-    "print('Top measurement:', result.top_measurement)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The `qiskit.aqua.components.oracles.TruthTableOracle` is not yet ported, but the behaviour can easily be achieved with the `qiskit.circuit.classicalfunction` module, see the tutorials on Grover's algorithm."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## More examples"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To construct the circuit we can call `construct_circuit` and pass the problem instance we are interested in:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANgAAAB7CAYAAAAWqE6tAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKCUlEQVR4nO3df0yU5wEH8O/dwR1YdB09lWqVgXK03DgWaDeKHXd0NqJbYheHSjYSiRsM6BbjlrTrhltluTSMtHZmic6hxC4hE4bGdepiHXf+oGtDNSrV7nT82lGkiJ14FaHC7Q/CzYMD7lUenvftvp/k/cPnvHu/EL73PPfee+/p/H6/H0QkhF52AKLPMxaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSCAWjEggFoxIIBaMSKAI2QHUbnhPDfxtHVL2rUuIh+EHm+7rvu+W78OND9pmNlAYYq0J+FpF4X3dV1Zm4MFyT4UFm4a/rQP+lkuyYyh244M29LyjrdxazDwdLhGJBGLBiARiwYgEYsGIBGLBiARiwYgEYsGIBGLBiARiwYgEUnXBRkZGUFVVhaSkJERFRSEtLQ1utxvJyckoKiqSHS+klU2NcHomno0w2fhs0+n1eLK8ABtbqvHdK2/C8YefwhQ7V3asKWkx8xhVF2zz5s2oqKhAcXExjh49ivXr1yM/Px+tra3IyMiQHU+TUn/0PJasegpvrfkZDqQXAwC+vvPHklNNTYuZx6j2XMTa2lrU1NTA5XLBbrcDAHJycnD27Fk0NDQgPT1dckJtsnzvOZx/rQ6+zo8BAO9XvIl1//gdHnrMjE+91yWnC02LmceodgZzOp3Izc0NlGvM8uXLERkZCZvNBgBob2+H3W6HxWJBamoqTp06JSOuJhjnzUHMY/PRd6E1MHarowdD/Z8iNuVL8oJNQYuZ76XKgnm9XrS0tCAvL2/CbZ2dnbBarTCZTACA4uJibNiwAR6PB7t378bGjRsxNDQ07T50Ol1Ym8vlUpz/1SuXMf/owaDtzA3lz7QulyvsnOM3t9s94fEiYqIBAEP9t4PGh/pvI3JutOJ8objdbs1lVppbCVUuEb1eLwAgLi4uaHxgYAButxurV68GAFy/fh2nT5/G4cOHAQBZWVlYtGgRGhsbsWrVqtkNfY+Xkp7Ay5aUoLGVTY2S0vzPXd8AgNFZ4V7GeXPw2a0BGZGmpcXM91LlDGY2mwEAHo8naLyyshLd3d2BAxydnZ1YuHBhYDYDgISEBHR0TP8BSb/fH9bmcDhm7gdTyOFwhJ1z/DZ+aQ2MPuv7vL2ITU0MjMUsXQDjvIfwyaWZ+VCp3W7XXGaluZVQ5QyWmJgIm80Gp9OJ2NhYLF68GPX19Thy5AgA8AjiA/D88ThSy9bi2pkWDH5yC0/+ogBdjefg8/bKjjYpLWYeo8oZTK/Xo66uDlarFSUlJSgsLITZbEZZWRkMBkPgAMfSpUvR09ODwcHBwH3b2toQHx8vK7rqXdx5CP8+/j6+dexVrD/3e+gMepx84beyY01Ji5nHqHIGAwCLxYLGxuDXLQUFBUhJSUF09OiLW7PZjBUrVqC6uhqlpaVoampCV1cXcnJyZEQGALydFXrfk43PNv/ICJq370fz9v2yo4RNi5nHqLZgoTQ3NyMzMzNobNeuXdi0aRN27NgBo9GI2tpaGI1GSQmJgmmmYD6fDx6PB6WlpUHjiYmJOHnypKRURFPTTMFiYmIwPDwsOwaRIqo8yEH0ecGCEQnEghEJxIIRCcSCEQnEghEJxIIRCaSZ98Fk0SXIO69R5r5pZrBg07jf7+ciArhEJBKKMxhNaX6GBV/5SR7mZ1igizDg5tUuXNrzV7TWq/f8TzVlZsFoUovsafhGzYu4sPMgTpa9gbt3hrBkZQaerixGzJIFuPB6veyIE6gtMwtGk8p0fh+th07j/Gt1gbH2v7yDiGgTsqp+iKt/asTtj/okJpxIbZn5GoxCmpf4KOYlPorWP0+8DF7rwdOAXofF9jQJySanxswsGIUU9cg8AMDtaxOf7Uc+u4vBG7cQZf7CbMeakhozs2AU0p2+fgDAnLhHJtymj4yAKXYu7ly/OduxpqTGzCwYhdTf2o3+9mtI+PYzE25LeH4FAKD71MXZjjUlNWZmwWhS7/68GsvWZcO2ZR2MD8fAEGVE/Dcz8dVXNuHS7rdUedk0tWXmUUSaVNffz+Fv619B2tY8fLl0LSLmmKDT6fDeL2twufqo7HghqS0zC0ZT+vi9D3F8YwWA0ctV5zZsx8PJSwCFV7idTWrKzCUihW2o/zaO5/8at7tvjP7BaoDszJzBSJGB3v8EvYmrBTIzs2DTGN5TA3/bzH3JgBK6hHieza9xLNg0/G0d8LfI/25l0ia+BiMSiAUjEogFIxKIBSMSiAUjEogFIxKIBSMSiAUjEkjVBRsZGUFVVRWSkpIQFRWFtLQ0uN1uJCcno6ioSHY8ommp+kyOzZs3o6GhAeXl5cjIyEBTUxPy8/PR29uLrVu3yo4X0sqmRjxrXoiXLSlhjc+mhLUr8HhhLr6YEo+IaBP2L9kgLYsSWs0NqLhgtbW1qKmpgcvlgt1uBwDk5OTg7NmzaGhoQHp6uuSE2jN404cPa47BEGVC1m+KZccJm1ZzAypeIjqdTuTm5gbKNWb58uWIjIyEzWYDAGzbtg0WiwV6vR719eq7Tp+afOQ6j7ZDZ+Dr6JEdRRGt5gZUWjCv14uWlhbk5eVNuK2zsxNWqxUmkwkAkJubi2PHjiE7O3u2YxJNS5VLRK/XCwCIi4sLGh8YGIDb7cbq1asDY1lZWfe1D51OF9b/O/60A3bzAkWP/eqVy3j9X/8MGvMN38Wz5oWKHsflcuE53a8U3WfMi7HZeNw4/77u+yDcbjfWhPm7HU9WZkBZbr+CT0arsmBmsxkA4PF4sGbNmsB4ZWUluru7kZGRIStaWF5KeiLkQQ76/6PKJWJiYiJsNhucTif279+PEydOoKSkBHv37gWAGSmY3+8Pa3M4HA+8r/vlcDjCzjl+G//adbbY7XbNZVaaWwlVFkyv16Ourg5WqxUlJSUoLCyE2WxGWVkZDAZD4AAHKaPT62EwRUJvHF24GEyRMJgiJaeanlZzAypdIgKAxWJBY2PwsqqgoAApKSmIjo6WlErbln0nG8+88ULg3wXttQCA+qdKVHmNwzFazQ2ouGChNDc3IzMzM2isvLwc+/btQ29vLy5evIgtW7bA7XZj2bJlUjK+nZWjaHw2XT3gwtUDLtkxFNNqbkClS8RQfD4fPB7PhDeYKyoq4PV6MTg4iL6+Pni9XmnlIhpPMzNYTEwMhoeHZccgUkQzMxiRFrFgRAKxYEQCsWBEArFgRAKxYEQCsWBEAmnmfTBZdAnxmtx3rDVhBpPMzn5lZRa5b51f6enBRBQ2LhGJBGLBiARiwYgEYsGIBGLBiARiwYgEYsGIBGLBiARiwYgEYsGIBGLBiARiwYgEYsGIBGLBiARiwYgEYsGIBGLBiARiwYgE+i/LKoj/oUx6WQAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 267.052x144.48 with 1 Axes>"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "power = 2\n",
-    "grover.construct_circuit(problem, power).draw('mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# Amplitude estimation<a href='#' id='ae'></a>\n",
-    "\n",
-    "## Summary\n",
-    "\n",
-    "For all amplitude estimation algorithms \n",
-    "* `AmplitudeEstimation`\n",
-    "* `IterativeAmplitudeEstimation`\n",
-    "* `MaximumLikelihoodAmplitudeEstimation`, and\n",
-    "* `FasterAmplitudeEstimation`\n",
-    "\n",
-    "the interface changed from\n",
-    "```python\n",
-    "qae = AmplitudeEstimation(algorithm_settings, estimation_settings)\n",
-    "result = qae.run()\n",
-    "```\n",
-    "to split problem/oracle settings and algorithm settings\n",
-    "```python\n",
-    "qae = AmplitudeEstimation(algorithm_settings)\n",
-    "problem = EstimationProblem(oracle_settings)\n",
-    "result = qae.amplify(problem)\n",
-    "```\n",
-    "<!-- See the documentation of the [deprecated amplitude estimation algorithms](https://qiskit.org/documentation/apidoc/qiskit.aqua.algorithms.html#amplitude-estimators) and [new ones](#). -->"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Transition guide\n",
-    "\n",
-    "Here, we'd like to estimate the probability of measuring a $|1\\rangle$ in our single qubit. If the state preparation is provided as circuit"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Target probability: 0.25\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAExklEQVR4nO3df0zUdRzH8eddZ5CYKWbgFXLOxOqYTqU5r82bshCpqN2trfWP5NZy/ZEmi805z2H9ZVszN60lU/6oaAoyhxI0KW/+VlphAulM7kIQKz3kl3Qe9+0PhObOjWORny8f34/tNvY9dvdiz32/3/Fjw2IYhoHQglX1ADF2JKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGJKZGbKoHqHJ60x5uNLYoee9k5ywWf/jWmL/uAxvzRmML1042qZ4xpuQyqxGJqRGJqZEH9p4Zr9yKYqYvyiAaiWAMROn5/Q8aPt1P8OBJ1dNiSMw4NGwr59y2CiwPWXl29UrcO9dSeb6F7kCH6ml3kcvsKBgDUS5+eRjrBBvJTofqOTEk5ihYJ9iYu2oFAF2XrypeE0sus3GY956HzDX52CYlYtwe4Pj6nYSagwAs3bGWy5XHuHL4RwCW7yni19Ja2v0N932nnJlxOLd9P18/s4pvnKu58v1PpL6QOfzcGd8eFhS9gW1iIjPzFhPu6lMSEkwas7KykszMTBISEsjIyKCkpISCggIcDofSXeGbvRwv/IynsheStuJ5APqvd9FccojFH61m/jovZzaXKttnupg1NTV4vV7sdjv79u2juLiYrVu3UldXp3oaAOHOHhq/OMjCDW+CxQLApb1HmDx7Bs0l1YQ7e5RtM9090+fz4XA4qK6uxmYbnOdyuZgzZw52u13xukHNuw7hfPslnn7dzaW9RwDobumgS/G3KqaK2dvbS319PYWFhcMhAdLT03G5XAQCgfu+qca7OebY7Z5blD039r/1+K9MdZkNhUIYhkFqamrMc/c6di8WiyWuh9/vH+v5cfP7/XHvHA1TnZlTp07FYrHQ0RF7ubrXMTM5tm6H6gnmOjOTkpLIysqioqKCSCQyfDwYDHLixIm4XsMwjLgebrf7//oyRuR2u+PeORqmigmwZcsWAoEAeXl5VFVVUVZWRk5ODikpKaqnmZ7pYubm5lJeXk5bWxterxefz0dRURHZ2dmqp5meqe6ZQzweDx6P565jR48eVbRm/DBlTLObmJpM5rv5XPyqDtfHazCiUbparnL8/Z1Kd5nuMjse2JfOo91/jpu/tVOdv5FvX9sEwLT5s5XuGjdnZmlpqZL3TV3iZNnuDwg1BZk08wlunA/wd2c3pzfuxogMDH9eNByhr/26ko1D5MwcQcepJv76+RI13s10nGzi1IZd2CYmEunrByAtJ4tXf/iExOmP0R/qVrpVYo7g0fQUuoPXAEiyTyNx2mRCTYHh51u/q+fAsvX0tV8n7cVFilYOkpgjmDI3jc4LrVisVoyowYw790sA68P/3qXCPbcY6A+rmgmMo3umKlPmpvFn/QWsCTYeeXwy9qXzaPy8CoAnly3A+c7LwOCfkbQdUfNL6SEScwS/bN8//PGB5YU4XlkCd37M1lp7ltbas6qmxZDL7CgFqsz397JDHtgzM9k5S7v3tsi/j9KHXGY1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE1IjE18g+I9pQDF0+ciAAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 133.526x84.28 with 1 Axes>"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "probability = 0.25\n",
-    "rotation_angle = 2 * np.arcsin(np.sqrt(probability))\n",
-    "\n",
-    "state_preparation = QuantumCircuit(1)\n",
-    "state_preparation.ry(rotation_angle, 0)\n",
-    "\n",
-    "objective_qubits = [0]  # the good states are identified by qubit 0 being in state |1>\n",
-    "\n",
-    "print('Target probability:', probability)\n",
-    "\n",
-    "state_preparation.draw(output='mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Grid-based estimate: 0.1464466\n",
-      "Improved continuous estimate: 0.2499999956539467\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import AmplitudeEstimation\n",
-    "\n",
-    "# instantiate the algorithm and passing the problem instance\n",
-    "ae = AmplitudeEstimation(3, state_preparation, quantum_instance=aqua_qinstance)\n",
-    "\n",
-    "# run the algorithm\n",
-    "result = ae.run()\n",
-    "\n",
-    "# print the results\n",
-    "print('Grid-based estimate:', result.estimation) \n",
-    "print('Improved continuous estimate:', result.mle)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Grid-based estimate: 0.1464466\n",
-      "Improved continuous estimate: 0.2499999956513743\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import AmplitudeEstimation, EstimationProblem\n",
-    "\n",
-    "problem = EstimationProblem(state_preparation=state_preparation, objective_qubits=objective_qubits)\n",
-    "ae = AmplitudeEstimation(num_eval_qubits=3, quantum_instance=qinstance)\n",
-    "\n",
-    "result = ae.estimate(problem)\n",
-    "print('Grid-based estimate:', result.estimation) \n",
-    "print('Improved continuous estimate:', result.mle)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that the old class used the last qubit in the `state_preparation` as objective qubit as default, if no other indices were specified. This default does not exist anymore to improve transparency and remove implicit assumptions."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "## More examples"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To construct the circuit for amplitude estimation, we can do"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdIAAADWCAYAAABlhgOUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAnnklEQVR4nO3de1iUdf7/8SenAQFB8IQiGS4egkAXLVe0wMyvlpWHylxdFzUPa2mW+sPDrqTSZt+2zLVU3GzjW55yy0Prmmmu4HqolAoFNVFBAY+AcRAFgfn9Qc5KooIjzIy8Htc118V87tP7vhnmxf25PzO3ndFoNCIiIiK3xd7SBYiIiNgyBamIiIgZFKQiIiJmUJCKiIiYQUEqIiJiBgWpiIiIGRSkIiIiZlCQioiImEFBKiIiYgYFqYiIiBkUpCIiImZQkIqIiJhBQSoiImIGBamIiIgZFKQiIiJmUJCKiIiYQUEqIiJiBgWpiIiIGRSkIiIiZlCQioiImEFBKiIiYgYFqYiIiBkUpCIiImZQkIqIiJhBQSoiImIGBamIiIgZHC1dQH1W9n4cxrQTFtm2nX9rHMaMqLX1fzPrQ3JT0mpt/dbCO8ifrjEjLV2GiE2x1PtDbf29KkgtyJh2AmPyQUuXUStyU9I4u+fu3DcRMc/d9v6grl0REREzKEhFRETMoCAVERExg4JURETEDApSERERMyhIRUREzKAgFRERMYOC9BppaWnY2dmxZs0aS5ciIiI2QkF6jcTERAC6dOli4UpERMRW6JuNrpGYmIiXlxdt2rSxdCk39Oju7TzSpDkz2wVWq93a2Nnb0/mPwwh4LgIHZwNZCUnsiVpKcW6BpUsTEQuz1fcHqz4jXb58Od27d8fNzQ0fHx9GjhxJbm4uAL169aJz587XLZOTk4OXlxfTp083tcXHxzNgwAD8/PxwcXHB19eX0aNHk5eXV2nZxMREQkNDa3en6rngiQPw6/MAGx+fwZrQcQA89O5LFq5KRKyBrb4/WG2QTpw4kZEjR/Lggw+ybt065s2bx+bNmxk6dCgAISEhHDp0iPLy8krLzZkzB4PBwMyZM01tSUlJ9OjRg9jYWLZs2UJ0dDQbNmxgypQplZZNTExUt24ta/e73iQvWk/hyXNcKSgiMeZjWj3ya9xaNbF0aSJiYbb6/mCVXburVq3ivffeIy4ujsjISFO7q6srQ4YMIT09nZCQEC5dusTx48cJCAgAIDU1ldjYWBYuXIiHh4dpuUmTJpl+Li8vJywsjKSkJLZt22ZqT09PJzc3t8qzXLkzDB6uuLdqSs7+46a2ghNnKcm/iHfgvVzMzLZgdSJiSbb8/mCVQTp37lxCQ0MZNmwYpaWlpvbAwIrrf2lpaYSEhACQkpJiCtJp06bRtm1bxowZY1qmrKyM1atXs2TJElJTUzl37pxp2rXduFcHGl0bpOnp6URGRnL69GmcnZ1ZvHgxDz30ULX2wc7O7pbzbO0WQXiTZtVa37XeSD3EO8d+rNRWWFbKI02aV3sd8fHx9LabXeNtV9c074fpYGhaqc3RvQEAJflFldpL8otwatig1mqpTQkJCTxejd+1iPyXpd4favr3ajQaqzWf1QVpRkYGhw8fBsDJyanKeTw9PQkMDMTBwYGUlBT69+/Pzp07WbduHZs2bcLBwcE0b2RkJGvXrmXChAlMmzaNJk2a4OjoSK9evQgODjbNl5iYiLe3d6WBRuPGjeO5557jhRdeYPfu3Tz77LOkpaVhMBhqae+rZ3rb+6ocbGTtSgsvARX/eV7L4OHKlYJLlihJRKyELb8/WF2QZmVlAbB06dIbDvwJDg7GycmJdu3akZycDMDUqVPp3bs3jz32mGm+5ORkVqxYwbJly3j++edN7bt27aKgoKDS2ecvBxplZ2ezc+dOPv/8cwDCwsJo2bIl27dvp0+fPrfcj+r8J1M6c47F7kcaERGBsRbD94tB0dfdb7Akv4jCzPN4B7chNyUdAPd7mmHwcOPCQcvc4Nxc4eHhvLE2wdJliNgUS70/1Nbfq9UFqa+vLwCOjo63HPgTEhJCSkoKq1evZu/evfzwww+Vpp88eRKADh06mNquXLnC5MmTAa4L0tGjR1datnnz5jg7O5va/P39OXHCNt/wrcWR5VsJfrE/Z3YlU3yhgC5/Gk7W9u8pzDxv6dJExMJs9f3B6oLUz8+P3r17M3XqVNPgn+LiYjIyMti0aRPLli2jcePGQEWQrl+/nhkzZjBq1KhKXbUAHTt2xMXFhenTpzNr1ixycnKYP38+Fy5cwMHBgU6dOgFw4sQJcnJyNGK3Dhx4dz0GT3ee2PwGDgYnTu3Yz44JCy1dlohYAVt9f7C6IAX45JNPiImJITY2lszMTBo2bEhAQAB9+/Y1hShUBGVxcTHZ2dnExMRctx5fX19WrlxJVFQU/fv3JygoiKioKDZu3IizszOurhV98VUNNLrnnns4e/YsxcXFprPStLQ0WrduXZu7fktfhfWsUbu1MZaXs2/uR+yb+5GlSxERK2Or7w9WGaReXl7Mnz+f+fPn33S+fv363fJa5MCBAxk4cGCltsGDB1d6PmjQoOvW06RJE7p3784HH3xgGmyUlZVFz562EVgiIlI3rDJIrUVsbCwjRoxgwYIFGAwGVq1aZfERuyIiYl0UpDfRpk0bduzYYekyRETEilntVwSKiIjYAgWpiIiIGRSkIiIiZlCQioiImEFBKiIiYgYFqYiIiBkUpCIiImbQ50gtyM7fcl83aMlti4jcTRSkFuQwZoSlSxARETOpa1dERMQMClIREREzKEhFRETMoCAVERExg4JURETEDApSERERMyhIRUREzKAgFRERMYOCVERExAwKUhERETMoSEVERMygIBURETGDglRERMQMuvuLBZW9H4cx7YRFtm3n31p3n7lLfDPrQ3JT0ixdRq3zDvKna8xIS5chch0FqQUZ005gTD5o6TLExuWmpHF2j15HIpairl0REREzKEhFRETMoCAVERExg4JURETEDApSERERMyhIRUREzKAgvUZaWhp2dnasWbPG0qWIiIiNUJBeIzExEYAuXbpYuBIREbEV+kKGayQmJuLl5UWbNm0sXYqIiNRA19dG4T+wBw7OTnzW9UUu5+TX2bat+ox0+fLldO/eHTc3N3x8fBg5ciS5ubkA9OrVi86dO1+3TE5ODl5eXkyfPt3UFh8fz4ABA/Dz88PFxQVfX19Gjx5NXl5epWUTExMJDQ2t3Z0y06O7t/P6keu/xeZG7VJ/2dnb02XWcIYkf8Cw1I+JWDYVZ++Gli5LpEr+/bvz2PoYhh75iN9nfFKjZZt2aU/Abx9h3cMvsyJgOI4NnBlx+lNcW3jXUrWVWW2QTpw4kZEjR/Lggw+ybt065s2bx+bNmxk6dCgAISEhHDp0iPLy8krLzZkzB4PBwMyZM01tSUlJ9OjRg9jYWLZs2UJ0dDQbNmxgypQplZZNTExUt67cNYInDsCvzwNsfHwGa0LHAfDQuy9ZuCqRqhXnFXI4bjPfRsfVeNmGrZtx6ewFiuvwLPRaVtm1u2rVKt577z3i4uKIjIw0tbu6ujJkyBDS09MJCQnh0qVLHD9+nICAAABSU1OJjY1l4cKFeHh4mJabNGmS6efy8nLCwsJISkpi27Ztpvb09HRyc3OrPMsVsUXtftebpPn/oPDkOQASYz7m6a8X4daqCRczsy1cnUhlp+KTAPDpFlTl9AZNG9HtL+Pw6RbIpfN5JC/eQPe3x7Mv5mN+/f+ew97gyLCjH5P9/VEah1Rcnhu4cyEYjRxYtIH973xaa7VbZZDOnTuX0NBQhg0bRmlpqak9MDAQqBhdGxISAkBKSoopSKdNm0bbtm0ZM2aMaZmysjJWr17NkiVLSE1N5dy5c6Zp13bjXh1odG2QRkdHs3r1ao4ePcqaNWt45plnamFvRe48g4cr7q2akrP/uKmt4MRZSvIv4h14r4JUbM5DiyZxpbCIf3QZj6OLgYhlFT2K6Z/v5nJ2HiEvP83asIkAuLdqyjN7l7Cux0sUnc6t9dqsLkgzMjI4fPgwAE5OTlXO4+npSWBgIA4ODqSkpNC/f3927tzJunXr2LRpEw4ODqZ5IyMjWbt2LRMmTGDatGk0adIER0dHevXqRXBwsGm+xMREvL29Kw006tu3LyNGjGDUqFE13g87O7tbzrO1WwThTZrVeN1vpB7inWM/VmorLCvlkSbNq72O+Ph4etvNrvG2q2ua98N0MDSttfVbi4SEBB6vxu+6NlV1rB3dGwBQkl9Uqb0kvwinhg3qrLY7yRqOtdwZNX1/cPXxpuVDwXz2mxe5UlDElYIifnj7H/T5JLpG263pa8hoNFZrPqsL0qysLACWLl16w4E/wcHBODk50a5dO5KTkwGYOnUqvXv35rHHHjPNl5yczIoVK1i2bBnPP/+8qX3Xrl0UFBRUOvusaqBRWFjYHduvO2l62/uY2S6wUtuju7dbqBqxRqWFl4CKM9NrGTxcuVJwyRIlidw21xaNASjMPG9qu3rJwhpY3WAjX19fABwdHenSpUuVj6tnqiEhIaSkpLB69Wr27t3L22+/XWldJ0+eBKBDhw6mtitXrjB58mSA64L0Tl4fNRqNt3xERETcse3VVERERLVqvN1HeHi4xfatLoWHh9fqcbzdY12SX0Rh5nm8g//bw+J+TzMMHm5cOGiZm8mbyxqOtR6195q9maIzOUBFl+1V7n43PqM1Gqs+k6zpa6i6rC5I/fz86N27N1OnTuWtt95i+/btbN68mffff5+BAweSk5NjmjckJIQff/yRGTNmMGrUqEpdtQAdO3bExcWF6dOns2XLFlatWkVYWBg5OTk4ODjQqVMnAE6cOEFOTo5G7Mpd5cjyrQS/2B93v2Y4uTegy5+Gk7X9+0r/1YtYCzt7exycnbA3VHSUOjg74eBccdJUdDqX07uS6TxrOE7uDXBp4knHyc/ecF2Xc/IpLyvDw79FndRudV27AJ988gkxMTHExsaSmZlJw4YNCQgIoG/fvjRu3Ng0X8eOHSkuLiY7O5uYmJjr1uPr68vKlSuJioqif//+BAUFERUVxcaNG3F2dsbVtaLbq6qBRiK27sC76zF4uvPE5jdwMDhxasd+dkxYaOmyRKr0q2cepsdfJ5ieD09fBcCnD4ynMPM8O15YQNhb43k2MdY0atfnN4FVrqvscgnfv/kJ4UtexsHZQPKSDez/69paq93OWJPz13oqIiKCCRMm3PFRu6Uz52BMtsyXKNjdH4jj66/W2vq/GBTN2T13/xdENO8WyGNr51q0Bh1rsTV34jXr2sKbwd/9zRS01VFbryGr69q1JrNmzaJVq1bs2bOHcePG0apVK44dO2bpskRExIooSG8iJiaGzMxMiouLycnJITMzk1/96leWLktERKyIVV4jFRERuZmi07nEtbCOL8nRGamIiIgZFKQiIiJmUJCKiIiYQUEqIiJiBgWpiIiIGRSkIiIiZtDHXyzIzr91vdy2iMjdREFqQQ5jRli6BBERMZO6dkVERMygIBURETGDunbF9tnZETi2H21/24uG9zSj9FIJZ3Yn8/2bq8lLzao0q0+3IHzCgvjh7TXXrabvZ3PY/HTlO+Lc9/zjtBn0EF733UPRmVzWhk2s1V0REdujM1KxeT0WvEjQ2CfZ+2ocK9tHsqHnK1zOzqPfxtdp1K4VAIFj+nHvU2GmZbzv96fr66MxeLoR9vZ4GjRtBIC9wZGQl5+mRY+Km8QXncklefF69v/1szrfLxGxDTojFavi6OpCp6mDaf14V1wae3DxVDa7o/7GuW8OVTl/swc7EDA4otL9DS+d+4mvZyzDs20rHpgdydahf+Zw3Jd0GNGHwDH9MHi6YWjkRtLbayjJu8jBv23kgdmReLb1JWLpZFJXb+f0zgMAnPjX1wAEDI6ok/0XEdujIBWr0n3+eFx9vPny2TkUZpyj4b0+N52/Va9QLmZlV3mT4OOf7aDb/47FwdkJY7kRo9EIP9/G3vT8Z1d/MhqNGMvK79TuiEg9oK5dsRoujT3w79+dPVFLKcw4B0BB+hkK0s/cdJmiM7lVTis6ewF7J0cMnm50GNGHy+fz+G7eStI37ObYpwl0mjIYg6cbQeOeZN/s/yMvNYuEP7yDd7C/qWtXRORWdEYqVsPdrxkAecdPV3uZyzn5uPp4VznNtbkX5WVlXM4t4OD7/wIqBhsB5B5I45sDHwCwa/Ji0zLlJaXsf+fT26pfROonnZGK1bh6FurRpkW1l8na/j1uvk1o1vW+66b5D3yIM7sPYiwtM7Wd2ZNS5Yhd4LoRuyIi1aEgFatxOSef9H/uodu8Mbi3agpAw3t9bnqd9OzXhzi29j88vOglWjwUjL2TIw2aNqLra6No1qUdiX9eblZNdg72ODg7YefkCHZ2ODg74eDsZNY6ReTuoq5dsSo7X1lE6LQh9F03F2cvdwozs9kTtfSm10l3TnyXwLFP0PW1Ubj7NcOxgTP5x0/zxcBocpKOmVVPx5efodPUwabnw9NXARDX4hmz1isidw8FqViV0ouX+TY6jm+j46q9jLG8nJTYz0mJ/RyAlhEdiVg6GYOHq9n1/PD2mht2BYuIgLp25S50Kj6J+HHzaRzcBnsn/a8oIrVL7zIWVPZ+HMa0ExbZtp1/a5u5+8ywox9X2X72m8N8NezPVU47FZ/Eqfik2ixL6qFvZn1Ibkqapcuodd5B/nSNGWnpMmyGgtSCjGknMCZf/0UCUtmKgOGWLkEEgNyUtCq//EPqN3XtioiImEFBKiIiYgYFqYiIiBkUpCIiImZQkIqIiJhBQSoiImIGBamIiIgZFKS/kJaWhp2dHWvW6GvhRETk1hSkv5CYmAhAly5dLFyJiIjYAn2z0S8kJibi5eVFmzZtLF1KlR7dvZ1HmjRnZrvAarWLSO2zs7en8x+HEfBcBA7OBrISktgTtZTi3AJLl2YzOv/xd7Tq3Rm3lo0pvXiZzG3fse+15ZT8VGjp0m7J6s9Ily9fTvfu3XFzc8PHx4eRI0eSm5sLQK9evejcufN1y+Tk5ODl5cX06dNNbfHx8QwYMAA/Pz9cXFzw9fVl9OjR5OXlVVo2MTGR0NDQ2t0pEVtkZ0fguCfoH/8Ovzu+giEpHxLx/hQ82/peN6tPtyA6TRlcxUqg72dzKj23NzjS7c2xDNr1LsNSP+aZfUvoMmu4Td33NXjiAPz6PMDGx2ewJnQcAA+9+5KFq7ItxvJy/jNhIasCR7Lh0am4tmhMjwUvWrqsarHqIJ04cSIjR47kwQcfZN26dcybN4/NmzczdOhQAEJCQjh06BDl5eWVlpszZw4Gg4GZM2ea2pKSkujRowexsbFs2bKF6OhoNmzYwJQpUyotm5iYqG5dkSr0WPAiQWOfZO+rcaxsH8mGnq9wOTuPfhtfp1G7VgAEjunHvU+FmZbxvt+frq+PxuDpRtjb42nQtBFQEZ4hLz9Nix7B2Ds4cDm3gG2R81jZPpIvBszCp8f9dP6T7XzHcrvf9SZ50XoKT57jSkERiTEf0+qRX+PWqomlS7MZ381bSW5yGsbSMopz8jm07F/4hAVZuqxqsdqu3VWrVvHee+8RFxdHZGSkqd3V1ZUhQ4aQnp5OSEgIly5d4vjx4wQEBACQmppKbGwsCxcuxMPDw7TcpEmTTD+Xl5cTFhZGUlIS27ZtM7Wnp6eTm5tb5VmuyN3E0dWFTlMH0/rxrrg09uDiqWx2R/2Nc98cqnL+Zg92IGBwBF8MijZ9afulcz/x9YxleLZtxQOzI9k69M8cjvuSDiP6EDimHwZPNwyN3Eh6ew0leRc5+LeNPDA7Es+2vkQsnUzq6u2c3nkAgO/fWGXa1sXMbFJXbKN9ZJ/aPxB3gMHDFfdWTcnZf9zUVnDiLCX5F/EOvJeLmdkWrM52tegRzIWDlrk7Vk1ZbZDOnTuX0NBQhg0bRmlpqak9MLDiGmBaWhohISEApKSkmIJ02rRptG3bljFjxpiWKSsrY/Xq1SxZsoTU1FTOnTtnmnZtN+7VgUZXg/TChQsMHz6cI0eO0KBBA5o3b87ixYtN27oZOzu7W86ztVsE4U2a3XK+X3oj9RDvHPuxUlthWSmPNGle7XXEx8fT2252jbddXdO8H6aDoWmtrd9aJCQk8Hg1fte16XaOdff543H18ebLZ+dQmHGOhvf63HT+Vr1CuZiVXeWdT45/toNu/zsWB2cnjOVGjEYjGCummZ7/7OpPRqMRY1n5deu6quJNNL1Sm7Uea0f3BgCU5BdVai/JL8KpYYM6q+1Oqu1jfavXbOt+XWn/+//hi0HRd3S7Nd2va1+7N2OVXbsZGRkcPnyY7777Dicnp0qPq+Hp6elJUFAQDg4OpKSkALBz507WrVvHW2+9hYODg2l9kZGRjBkzhrCwMJYtW8bu3bv59ttvadiwIcHBwab5EhMT8fb2Ng00srOz4+WXX+bIkSMkJSXxxBNPMHKk5e/RN73tfZx/bGClR3dvdSFJ9bg09sC/f3f2RC2lMKPin8qC9DMUpJ+56TJFZ3KrnFZ09gL2To4YPN3oMKIPl8/n8d28laRv2M2xTxPoNGUwBk83gsY9yb7Z/0deahYJf3gH72B/WvQIvm59gWP60bxbIN9dc5ZqzUoLLwEVZ6bXMni4cqXgkiVKsmmtn+hG2F/+wLbIN8g9YBv3frXKIM3KygJg6dKl7N27t8pHcHAwLi4utGvXjuTkZACmTp1K7969eeyxx0zrSk5OZsWKFbz77ru8+eabPPnkk3Tr1o2SkhIKCgoqdeP+cqBRo0aNePTRR03Pw8LCSEur3i/WaDTe8hEREWHOYTJLREREtWq83Ud4eLjF9q0uhYeH1+pxrI1j7e5X0QuSd/x0tZe5nJOPq493ldNcm3tRXlbG5dwCDr7/L9I27DJNyz2Qxjd//ICSvIvsmryYS+d/AqC8pJT973xq6tq9KnDsEwRPGMCXz8zmYlblLlFrPdYl+UUUZp7HO/i/I/3d72mGwcPNZromf6m2j/WNXrMBz/Uk7M2xbIt8gzO7Uyy+X9VllV27vr4VowAdHR1vOfAnJCSElJQUVq9ezd69e/nhhx8qTT958iQAHTp0MLVduXKFyZMnA1wXpKNHj77hthYsWMCAAQNqsisiVufqWahHmxbkHcms1jJZ278n5KVBNOt633XXUf0HPsSZ3QcxlpaZ2s7sSeHMnqrfCDc//WqV7SGvPEP73/Xmi0Gvkn/sVLXqshZHlm8l+MX+nNmVTPGFArr8aThZ27+nMPO8pUuzGfc9/zgdJz/Llt++Rk7SMUuXUyNWGaR+fn707t2bqVOnmgb/FBcXk5GRwaZNm1i2bBmNGzcGKoJ0/fr1zJgxg1GjRlXqqgXo2LEjLi4uTJ8+nVmzZpGTk8P8+fO5cOECDg4OdOrUCYATJ06Qk5Nzw+CeM2cOR48e5d///net7rtIbbuck0/6P/fQbd4Ydk56j8LM86ZrpDfq3j379SGOrf0PDy96iV2vLObs14dwbuROyKRBNOvSji8Gmnctq8us4dz7VBibB0VTcOKsWeuyhAPvrsfg6c4Tm9/AweDEqR372TFhoaXLsildXxtF+ZVS+n42u1L7igDrH71tlUEK8MknnxATE0NsbCyZmZk0bNiQgIAA+vbtawpRqAjK4uJisrOziYmJuW49vr6+rFy5kqioKPr3709QUBBRUVFs3LgRZ2dnXF0rrmv8cqDRtV577TU2btzI1q1bTfNbyldhPWvULlKVna8sInTaEPqum4uzlzuFmdnsiVp60+ukOye+S+DYJ+j62ijc/Zrh2MCZ/OOn+WJgtFlnEG6tmnD/C/0pK77CU9veMrUXZmazIeKV215vXTKWl7Nv7kfsm/uRpUuxWXEtnrF0CbfNaoPUy8uL+fPnM3/+/JvO169fv1v2ZQ8cOJCBAwdWahs8uPKHxQcNGlTleubMmcOmTZvYunUrjRo1ql7xIlau9OJlvo2O49vouGovYywvJyX2c1JiPwegZURHIpZOvm6QTU1dzMy26TdREascbGQtUlJSmD17Njk5OURERNCpUydTV7BIfXcqPon4cfNpHNwGeyer/Z9cpNbp1X8TQUFBNRq5JWLLhh39uMr2s98c5qthf65y2qn4JE7FJ9VmWSJWT0EqIoBtDOoQsUbq2hURETGDglRERMQMClIREREzKEhFRETMoCAVERExg4JURETEDPr4iwXZ+beul9sWkfrNO8j/rtqugtSCHMaMsHQJIiJ1rmuM5e/rfCepa1dERMQMClIREREzKEhFRKyNnR2B456gf/w7/O74CoakfEjE+1PwbOt73aw+3YLoNGVwFSuBvp/NueEmHBs4M2jPe/w+45M7VnZ9pSAVEbEyPRa8SNDYJ9n7ahwr20eyoecrXM7Oo9/G12nUrhUAgWP6ce9TYaZlvO/3p+vrozF4uhH29ngaNG0EgL3BkZCXn6ZFj+BK2+j8x2EUnjxXZ/t0N1OQiojUIkdXF7pE/56nv17EsNSPGZDwDs263nfD+Zs92IGAwRHsmPBXTiUkUX6llEvnfuLrGcvIOZDGA7MjATgc9yWuzb0InTmUe/uHEfBcBElvr6Ek7yIH/7aRB2ZH4tnWl4ilk7lw6CSndx4wbaP5b+6jedf7OLBofW3vfr2gUbsiIrWo+/zxuPp48+WzcyjMOEfDe31uOn+rXqFczMrm7J6D1007/tkOuv3vWBycnTCWGytu8/jznR5Nz3929Sej0YixrNzU7tDAQNhf/sCOCQtxcnUxe/9EZ6QiIrXGpbEH/v27sydqKYUZFd2oBelnKEg/c9Nlis7kVjmt6OwF7J0cMXi60WFEHy6fz+O7eStJ37CbY58m0GnKYAyebgSNe5J9s/+PvNQsEv7wDt7B/qau3c4zh5GxNZGcpGN3fofrKZ2RiojUEne/ZgDkHT9d7WUu5+Tj6uNd5TTX5l6Ul5VxObeAg+//C6gYbASQeyCNbw58AMCuyYtNy5SXlLL/nU+Bim5j356/5vPeU2u+M3JDOiMVEaklV89CPdq0qPYyWdu/x823SZXXUf0HPsSZ3QcxlpaZ2s7sSeGHt9dUua7NT79a6XnLh0Jwa9mYZ/fFMiTl7zwSF4W9owNDUv5Oq96dq12jVKYzUhGRWnI5J5/0f+6h27wx7Jz0HoWZ503XSG/UvXv260McW/sfHl70ErteWczZrw/h3MidkEmDaNalHV8MjL7telKW/pMjK78yPW/auT3hS17m80enUnyh8LbXW98pSEVEatHOVxYROm0IfdfNxdnLncLMbPZELb3pddKdE98lcOwTdH1tFO5+zXBs4Ez+8dN8MTDarGubVwovcaXwkul5cU4+AEWnq74mK9WjIBURqUWlFy/zbXQc30bHVXsZY3k5KbGfkxL7OQAtIzoSsXQyBg/XO1rbmT0pfOT33B1dZ32ka6QiIlbuVHwS8ePm0zi4DfZOOv+xNvqNWNA3sz4kNyXNItv2DvK/6+7AIGIrhh39uMr2s98c5qthf65y2qn4JE7FJ9VmWXKbFKQWlJuSVuWHrkXk7rYiYLilS5A7SF27IiIiZlCQioiImEFBKiIiYgZdI7UBfT+bQ9PO7SgvLcVYVk7hyXMk/XUtJzbusXRpIiL1noLURiQt+JT9Cz7DzsGe+0Y9RvjiSaxLTrvph7pFRKT2qWvXxhjLyjmy/CvsnRzxDrrX0uWIiNR7ClIbY+/kSPvIPgDk1+COEiIiUjvUtWsjQl4axP1/eApHdxeMV8rYNXkxFw6dAODhRZM4vm4nmV8lAvDIh1EcjvuSUwn68LaISG2rt2ek5eXlvPXWW7Rt2xYXFxc6duxIQkIC7du3Z+zYsZYu7zr7F65lZYdIVgeNIvPf3+PT/X7TtG+jP+TXUUNwdHXhnse7UpJfZLUh6t+/O4+tj2HokY/4fcYnli7nrqXjXHd0rKXeBunzzz9PTEwM48aN44svvmDw4MH89re/5fjx43TubL335SvJu8iuKUto1SsUvz4PABW3ajq07F90fW0UHV9+mm9fjbNskTdRnFfI4bjNNfoCb6k5Hee6o2Mt9bJrd9WqVcTFxREfH094eDgAPXv25LvvvmPt2rWEhoZauMKbK/mpkJS/bSR0xlAytuwDo5Gja+JpO6wXh5ZtouQn672v4NXvCvXpFmThSu5uOs51R8da6uUZ6euvv07fvn1NIXpVQEAATk5OhISEAJCenk54eDjt2rUjODiY//znP5Yot0qH3v8Xrs0aEfDsf/ehIO0M+fo4jIhInap3Z6SZmZkkJyfzyiuvXDft5MmTBAUF4ezsDMC4ceN47rnneOGFF9i9ezfPPvssaWlpGAyGOq1589OvXtd2pfASqwJ19xYREUurd2ekmZmZAPj4+FRqv3TpEgkJCaZu3ezsbHbu3Mnzzz8PQFhYGC1btmT79u3V2o6dnd0tHwkJCXdwz2omISGhWjXe7sOS+1aXavs46lj/l4513bGGY20Nj+qqd0HapEkTAI4cOVKp/c033+T06dOmgUYnT56kefPmprNTAH9/f06cOFF3xdbQzpcXce7bw5YuQ0SkXql3QdqmTRtCQkJ4/fXX+eijj9i2bRvjx4/n73//O8AdG7FrNBpv+fjlNdq6FB4eXq0ab/dxo32zs7fHwdkJe0PFVQUHZyccnJ3qctfvqNo+jrd7rO+24ww61nXJGo61NTyqq95dI7W3t+cf//gH48aNY/z48TRu3JjIyEhefPFFZs6caRpodM8993D27FmKi4tNZ6VpaWm0bt3akuXbvF898zA9/jrB9Hx4+ioAPn1gPIWZ5y1V1l1Hx7nu6FhLvQtSgHbt2l13rXP48OEEBgbSoEEDoKILuHv37nzwwQemwUZZWVn07NnTEiXfNY6uiefomnhLl3HX03GuOzrWUi+DtCr79u3jN7/5TaW22NhYRowYwYIFCzAYDKxatarOR+yKiIh1U5AChYWFHDlyhBdeeKFSe5s2bdixY4eFqro5Vx9v7n/hKY6s2EbYX/6Asbyc/LTT7HplsaVLExGpVxSkgLu7O2VlZZYuo0ZaPhzCqYT95B07xaan/ghA93deoHHHX5GTdMzC1YmI1B8KUhvg0y2Inn//f1w4eAL3e5qRm5xO8U8FfPPHv2Ms/e8/AOUlpRSdyrFgpSIi9U+9+/iLLTrz9UGyfzjK5qdf5cyeg3w9430cXV0oLboMgN//dKH/9vm4NPXk8oUCC1crIlK/KEhtQMPWzSk4cRYAt5aNcWnswYWD6abpGVv2saHnZIpO5eDX23rvXCMicjdSkNqARu39+OnHDOzs7TGWG2nx8/VRwPQhcICSwkuUXS6xVJkiIvWSrpHagEbt/Ti/70fsnR1p0MSDlg+HkBL7TwB8e/6aoHFPAJB//DRZ8dZ5Q28RkbuVgtQGHFi41vTzhkemcO+T3eDnr6/K+HIvGV/utVRpIiL1nrp2bVD6P/dYugQREfmZzkgtyDvI/67dtiX3rS5Zw35aQw11wRr20xpqqAv1ZT/vFDtjTb7iXkRERCpR166IiIgZFKQiIiJmUJCKiIiYQUEqIiJiBgWpiIiIGRSkIiIiZlCQioiImEFBKiIiYgYFqYiIiBkUpCIiImZQkIqIiJhBQSoiImIGBamIiIgZFKQiIiJmUJCKiIiYQUEqIiJiBgWpiIiIGRSkIiIiZvj/uZ7Qkpybs8YAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 598.915x264.88 with 1 Axes>"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ae.construct_circuit(estimation_problem=problem).draw('mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now that the problem is separated from the algorithm we can exchange `AmplitudeEstimation` with any other algorithm that implements the `AmplitudeEstimator` interface."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Estimate: 0.24999999999999994\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import IterativeAmplitudeEstimation\n",
-    "\n",
-    "iae = IterativeAmplitudeEstimation(epsilon_target=0.01, alpha=0.05, quantum_instance=qinstance)\n",
-    "\n",
-    "result = iae.estimate(problem)\n",
-    "print('Estimate:', result.estimation)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Estimate: 0.2500081904035319\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import MaximumLikelihoodAmplitudeEstimation\n",
-    "\n",
-    "mlae = MaximumLikelihoodAmplitudeEstimation(evaluation_schedule=[0, 2, 4], quantum_instance=qinstance)\n",
-    "\n",
-    "result = mlae.estimate(problem)\n",
-    "print('Estimate:', result.estimation)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# Minimum eigenvalues<a href='#' id='mes'></a>\n",
-    "\n",
-    "## Summary\n",
-    "\n",
-    "The interface remained mostly the same, but where previously it was possible to pass the operator in the initializer \n",
-    "\n",
-    "Also the operators must now be constructed with operators from `qiskit.opflow` instead of `qiskit.aqua.operators`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Transition guide"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Assume we want to find the minimum eigenvalue of \n",
-    "$$\n",
-    "H = Z \\otimes I.\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### NumPy-based eigensolver<a id='npmes' href='#'></a>\n",
-    "\n",
-    "**Previously:**\n",
-    "\n",
-    "Previously we imported the operators from `qiskit.aqua.operators`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.aqua.operators import Z, I\n",
-    "\n",
-    "observable = Z ^ I"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "and then solved for the minimum eigenvalue using"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-1+0j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import NumPyMinimumEigensolver\n",
-    "\n",
-    "mes = NumPyMinimumEigensolver()\n",
-    "result = mes.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "It used to be possible to pass the observable in the initializer, which is now not allowed anymore due to the problem-algorithm separation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-1+0j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "mes = NumPyMinimumEigensolver(observable)\n",
-    "result = mes.compute_minimum_eigenvalue()\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**\n",
-    "\n",
-    "Now we need to import from `qiskit.opflow` but the other syntax remains exactly the same:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.opflow import Z, I\n",
-    "\n",
-    "observable = Z ^ I "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-1+0j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import NumPyMinimumEigensolver\n",
-    "\n",
-    "mes = NumPyMinimumEigensolver()\n",
-    "\n",
-    "result = mes.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "### VQE<a id='vqe' href='#'></a>\n",
-    "\n",
-    "The same changes hold for VQE. Let's use the `RealAmplitudes` circuit as ansatz:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 267.052x144.48 with 1 Axes>"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.circuit.library import RealAmplitudes\n",
-    "\n",
-    "ansatz = RealAmplitudes(2, reps=1)\n",
-    "ansatz.draw(output='mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**\n",
-    "\n",
-    "Previously, we had to import both the optimizer and operators from Qiskit Aqua:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-0.999999995494166+0j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import VQE\n",
-    "from qiskit.aqua.components.optimizers import COBYLA\n",
-    "from qiskit.aqua.operators import Z, I\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "vqe = VQE(var_form=ansatz, optimizer=COBYLA(), quantum_instance=aqua_qinstance)\n",
-    "result = vqe.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:** \n",
-    "\n",
-    "Now we import optimizers from `qiskit.algorithms.optimizers` and operators from `qiskit.opflow`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-0.999999988424407\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import VQE\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
-    "from qiskit.opflow import Z, I\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "vqe = VQE(var_form=ansatz, optimizer=COBYLA(), quantum_instance=qinstance)\n",
-    "result = vqe.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that the `qiskit.aqua.components.variational_forms` are completely deprecated in favor of circuit objects. Most variational forms have already been ported to circuit library in previous releases and now also `UCCSD` is part of the Qiskit Nature's circuit library:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 628.397x264.88 with 1 Axes>"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.circuit import ParameterVector\n",
-    "from qiskit.chemistry.components.variational_forms import UCCSD\n",
-    "\n",
-    "varform = UCCSD(4, (1, 1), qubit_mapping='jordan_wigner', two_qubit_reduction=False)\n",
-    "parameters = ParameterVector('x', varform.num_parameters)\n",
-    "\n",
-    "circuit = varform.construct_circuit(parameters)\n",
-    "circuit.draw('mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1591.6x1167.88 with 1 Axes>"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit_nature.mappers.second_quantization import JordanWignerMapper\n",
-    "from qiskit_nature.operators.second_quantization.qubit_converter import QubitConverter\n",
-    "from qiskit_nature.circuit.library import UCCSD\n",
-    "\n",
-    "qubit_converter = QubitConverter(JordanWignerMapper())\n",
-    "\n",
-    "circuit = UCCSD(qubit_converter, (1, 1), 4)\n",
-    "circuit.draw('mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "### QAOA<a id='qaoa' href='#'></a>\n",
-    "\n",
-    "For Hamiltonians from combinatorial optimization (like ours: $Z \\otimes I$) we can use the QAOA algorithm."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-0.9999999761938837+0j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import QAOA\n",
-    "from qiskit.aqua.components.optimizers import COBYLA\n",
-    "from qiskit.aqua.operators import Z, I\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "qaoa = QAOA(optimizer=COBYLA(), quantum_instance=aqua_qinstance)\n",
-    "result = qaoa.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-0.9999999897469609\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import QAOA\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
-    "from qiskit.opflow import Z, I\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "qaoa = QAOA(optimizer=COBYLA(), quantum_instance=qinstance)\n",
-    "result = qaoa.compute_minimum_eigenvalue(observable)\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### More examples"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 387.452x144.48 with 1 Axes>"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "qaoa.construct_circuit([1, 2], observable)[0].draw(output='mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# (General) Eigenvalues <a href='#' id='es'></a>\n",
-    "\n",
-    "Currently, only NumPy-based calculations are available, but more algorithms will be available in the chemistry package.\n",
-    "\n",
-    "As for the `MinimumEigenSolver`, the only change for the `EigenSolver` is the type for the observable and the import path."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-1.+0.j -1.+0.j  1.+0.j]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import NumPyEigensolver\n",
-    "from qiskit.aqua.operators import I, Z\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "es = NumPyEigensolver(k=3)  # get the lowest 3 eigenvalues\n",
-    "\n",
-    "result = es.compute_eigenvalues(observable)\n",
-    "print(result.eigenvalues)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-1.+0.j -1.+0.j  1.+0.j]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import NumPyEigensolver\n",
-    "from qiskit.aqua.operators import I, Z\n",
-    "\n",
-    "observable = Z ^ I\n",
-    "\n",
-    "es = NumPyEigensolver(k=3)  # get the lowest 3 eigenvalues\n",
-    "\n",
-    "result = es.compute_eigenvalues(observable)\n",
-    "print(result.eigenvalues)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "# Shor's algorithm<a href='#' id='shor'></a>\n",
-    "\n",
-    "## Summary\n",
-    "\n",
-    "The arguments `N` and `a` moved from the initializer to the `Shor.factor` method."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We'll be using a shot-based readout for speed here."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "aqua_qasm_qinstance = AquaQuantumInstance(Aer.get_backend('qasm_simulator'))\n",
-    "qasm_qinstance = QuantumInstance(Aer.get_backend('qasm_simulator'))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Factors: [3]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import Shor\n",
-    "\n",
-    "shor = Shor(N=9, a=2, quantum_instance=aqua_qinstance)\n",
-    "\n",
-    "result = shor.run()\n",
-    "print('Factors:', result['factors'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Factors: [3]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import Shor\n",
-    "\n",
-    "shor = Shor(quantum_instance=qinstance)\n",
-    "\n",
-    "result = shor.factor(N=9, a=2)\n",
-    "print('Factors:', result.factors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "## HHL<a href='#' id='hhl'></a>\n",
-    "\n",
-    "HHL has been completely refactored to allow an intuitive interface and return an efficient, circuit-based representation of the result. \n",
-    "\n",
-    "Assume we want to solve the following linear system\n",
-    "$$\n",
-    "\\begin{pmatrix}\n",
-    "1 & -1/3 \\\\\n",
-    "-1/3 & 1 \\\\\n",
-    "\\end{pmatrix}\n",
-    "\\vec x\n",
-    "=\n",
-    "\\begin{pmatrix}\n",
-    "1 \\\\ 0\n",
-    "\\end{pmatrix}\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "matrix = np.array([[1, -1/3], [-1/3, 1]])\n",
-    "vector = np.array([1, 0])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ 0.66575607-5.39389682e-15j -0.38561455+4.35672537e-15j]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.circuit.library import QFT\n",
-    "from qiskit.aqua.algorithms import HHL\n",
-    "from qiskit.aqua.components.eigs import EigsQPE\n",
-    "from qiskit.aqua.components.reciprocals import LookupRotation\n",
-    "from qiskit.aqua.components.initial_states import Custom\n",
-    "from qiskit.aqua.operators import MatrixOperator\n",
-    "\n",
-    "def create_eigs(matrix, num_auxiliary, num_time_slices, negative_evals):\n",
-    "    ne_qfts = [None, None]\n",
-    "    if negative_evals:\n",
-    "        num_auxiliary += 1\n",
-    "        ne_qfts = [QFT(num_auxiliary - 1), QFT(num_auxiliary - 1).inverse()]\n",
-    "    return EigsQPE(MatrixOperator(matrix=matrix),\n",
-    "                   QFT(num_auxiliary).inverse(),\n",
-    "                   num_time_slices=num_time_slices,\n",
-    "                   num_ancillae=num_auxiliary,\n",
-    "                   expansion_mode='suzuki',\n",
-    "                   expansion_order=2,\n",
-    "                   evo_time=None, \n",
-    "                   negative_evals=negative_evals,\n",
-    "                   ne_qfts=ne_qfts)\n",
-    "\n",
-    "orig_size = len(vector)\n",
-    "\n",
-    "matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(matrix, vector)\n",
-    "\n",
-    "# Initialize eigenvalue finding module\n",
-    "eigs = create_eigs(matrix, 3, 50, False)\n",
-    "num_q, num_a = eigs.get_register_sizes()\n",
-    "\n",
-    "# Initialize initial state module\n",
-    "init_state = Custom(num_q, state_vector=vector)\n",
-    "\n",
-    "# Initialize reciprocal rotation module\n",
-    "reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time)\n",
-    "algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs,\n",
-    "           init_state, reci, num_q, num_a, orig_size)\n",
-    "\n",
-    "result = algo.run(aqua_qinstance)\n",
-    "print(result.solution)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jul/Qiskit/qiskit-terra/qiskit/providers/basicaer/statevector_simulator.py:144: UserWarning: Option backend_options is not used by this backend\n",
-      "  return super().run(qobj, backend_options=backend_options)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 547.521x264.88 with 1 Axes>"
-      ]
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms.linear_solvers import HHL\n",
-    "\n",
-    "hhl = HHL()\n",
-    "result = hhl.solve(matrix, vector)\n",
-    "result.state.draw('mpl', style='iqx')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that the solution vector is not returned, since that would require an exponentially expensive simulation of the solution circuit. Instead, the circuit can be used to evaluate observables on the solution. For details, see the documentation and docstrings of HHL."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### NumPy-based linear solver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1.125, 0.375]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.aqua.algorithms import NumPyLSsolver\n",
-    "\n",
-    "ls = NumPyLSsolver(matrix, vector)\n",
-    "result = ls.run()\n",
-    "print(result.solution)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Now:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1.125 0.375]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms import NumPyLinearSolver\n",
-    "\n",
-    "ls = NumPyLinearSolver()\n",
-    "result = ls.solve(matrix, vector)\n",
-    "print(result.state)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Phase estimation<a href='#' id='pe'></a>\n",
-    "\n",
-    "Let's consider the problem of finding the eigenvalue of"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "$$\n",
-    "H = 0.5 X + Y + Z\n",
-    "$$\n",
-    "with the input state $|0\\rangle$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "state_in = np.array([1, 0])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "**Previously:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.78125\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit.circuit.library import QFT\n",
-    "from qiskit.aqua.algorithms import QPE\n",
-    "from qiskit.aqua.components.initial_states import Custom\n",
-    "from qiskit.aqua.operators import I, X, Y, Z\n",
-    "\n",
-    "n_ancillae = 5\n",
-    "num_time_slices = 1\n",
-    "\n",
-    "op = 0.5 * X + Y + Z\n",
-    "\n",
-    "state_preparation = Custom(op.num_qubits, state_vector=state_in)\n",
-    "iqft = QFT(n_ancillae, do_swaps=False).inverse().reverse_bits()\n",
-    "\n",
-    "qpe = QPE(op, state_preparation, iqft, num_time_slices, n_ancillae,\n",
-    "          expansion_mode='trotter', \n",
-    "          shallow_circuit_concat=True)\n",
-    "\n",
-    "\n",
-    "result = qpe.run(aqua_qinstance)\n",
-    "\n",
-    "print(result.eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**New:**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.78125\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit import BasicAer\n",
-    "from qiskit.algorithms import HamiltonianPhaseEstimation\n",
-    "from qiskit.opflow import I, X, Y, Z, StateFn, PauliTrotterEvolution, Suzuki\n",
-    "\n",
-    "state_preparation = StateFn(state_in)\n",
-    "\n",
-    "op = 0.5 * X + Y + Z\n",
-    "\n",
-    "evolution = PauliTrotterEvolution()\n",
-    "\n",
-    "qpe = HamiltonianPhaseEstimation(5, quantum_instance=qinstance)\n",
-    "result = qpe.estimate(op, state_preparation)\n",
-    "\n",
-    "print(result.most_likely_eigenvalue)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.7.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}