Understanding Aqua's Operator Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Understanding Aqua's Operator Flow\n",
    "\n",
    "_donny@, 14-May-20_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Table of Contents**\n",
    "\n",
    "1  [Overview](#Overview) <br>\n",
    "&emsp;&emsp;1.1  [🚨🚨🚨Disclaimers🚨🚨🚨](#🚨🚨🚨Disclaimers🚨🚨🚨) <br>\n",
    "&emsp;&emsp;1.2  [Basic Design Principles](#Basic-Design-Principles) <br>\n",
    "&emsp;&emsp;1.3  [Basic Definitions](#Basic-Definitions) <br>\n",
    "&emsp;&emsp;1.4  [Object Structure](#Object-Structure) <br>\n",
    "&emsp;&emsp;1.5  [Motivating Example](#Motivating-Example) <br>\n",
    "2  [State Functions and Measurements](#State-Functions-and-Measurements) <br>\n",
    "&emsp;&emsp;2.1  [.eval(state) vs .compose(state)](#.eval(state)-vs-.compose(state)) <br>\n",
    "&emsp;&emsp;2.2  [Arithmetic Operations](#Arithmetic-Operations) <br>\n",
    "3  [PrimitiveOps](#PrimitiveOps) <br>\n",
    "&emsp;&emsp;3.1  [OperatorStateFn](#OperatorStateFn) <br>\n",
    "4  [ListOps](#ListOps) <br>\n",
    "&emsp;&emsp;4.1  [Hierarchical ListOps](#Hierarchical-ListOps) <br>\n",
    "5  [Converters](#Converters) <br>\n",
    "&emsp;&emsp;5.1  [Evolutions, exp_i(), and the EvolvedOp](#Evolutions,-exp_i(),-and-the-EvolvedOp) <br>\n",
    "&emsp;&emsp;5.2  [Expectations](#Expectations) <br>\n",
    "&emsp;&emsp;5.3  [Executing CircuitStateFns with the CircuitSampler](#Executing-CircuitStateFns-with-the-CircuitSampler) <br>\n",
    "6  [Conclusion](#Conclusion) <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "A library for Quantum Algorithms & Applications is more than a collection of procedural code wrapped in Python functions. It needs to provide tools to make writing algorithms simple and easy. This is the layer of modules between the circuits and algorithms, providing the language and computational primitives for Quantum algorithms research.\n",
    "\n",
    "In Aqua, we call this layer the Operator flow. It works by unifying computation with theory through the common language of functions and operators in a way which preserves physical intuition and programming freedom. In the Operator flow, we construct functions over binary variables, manipulate those functions with operators, and evaluate properties of these functions with measurements. \n",
    "\n",
    "Below, we'll describe the key players in the Operator flow, and show some examples of how they can be used to construct some familiar quantum algorithms. This notebook assumes a basic familiarity with Quantum Algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 🚨🚨🚨Disclaimers🚨🚨🚨\n",
    "1. The Operator flow is a large and self-referential system. Do not worry if you don't immediately feel comfortable with all of its moving parts - like any system of abstractions, it can take time and play to feel comfortable. We feel that this is a worthwhile investment, as once you begin to feel comfortable with the system, algorithm development is super fast and easy.\n",
    "\n",
    "2. The Qiskit 0.19 release includes the ***v0*** version of the Operator flow, and there are plenty of kinks to work out. We appreciate your patience, diligence to point out bugs, feedback (by [filing bugs in github](https://github.com/Qiskit/qiskit-aqua/issues) ), and contributions as the Operator flow matures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Basic Design Principles\n",
    "\n",
    "* *Batteries Included* - We prioritize quick and easy access to the tools you're most likely to reach for when prototyping.\n",
    "\n",
    "* *Physically Formal* - The Operator flow was built to be mathematically formal down to its very bottom primitives, so that it may serve as a lingua franca between the theory and implementation of Quantum algorithms.\n",
    "\n",
    "* *Powerful OR Readable* - We've tried to let any operation be as succinct or verbose as you want it to be, including both rich syntactic sugar and long-form interfaces.\n",
    "\n",
    "* *Fast by Default* - We use thoughtfully selected defaults so that algorithms run as fast as possible at many scales, and so you only need to toggle the settings you care about. We want you to be able to trust that we're running your problem as fast as we can, and if you find a way to run it faster, you should [let us know!](https://github.com/Qiskit/qiskit-aqua/issues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Basic Definitions\n",
    "\n",
    "Before getting into the details of the code, it's important to note that three mathematical concepts unpin the Operator flow. We derive most of the inspiration for the code structure from [John Watrous's Quantum Information formalism](https://cs.uwaterloo.ca/~watrous/TQI/) (but do not follow it exactly), so it may be worthwhile to review Chapters I and II, which are free online, if you feel the concepts are not clicking.\n",
    "\n",
    "1. **\"State functions\"** - An $n$-qubit State function is a complex function over $n$ binary variables, which we will often refer to as _$n$-qubit binary strings_. For example, the traditional quantum \"zero state\" is a 1-qubit state function, with a definition of $Zero(0) = 1$ and $Zero(1) = 0$. It is often convenient to think about State functions as traditional kets (i.e. $Zero = |0\\rangle$), but be warned, **State functions need not be normalized.** They are just functions.\n",
    "\n",
    "1. **\"Operators\"** - An $n$-qubit Operator is a linear function taking $n$-qubit state functions to $n$-qubit state functions. For example, the Pauli X Operator is defined by $X(Zero) = One$ and $X(One) = Zero$. Therefore, $X(Zero)(0) = 0$. Equivalently, an Operator can be defined as a complex function over two n-qubit binary strings, and it is sometimes convenient to picture things this way. By this definition, our Pauli $X$ can be defined by its typical matrix elements, $X(0, 0) = 0$, $X(1, 0) = 1$, $X(0, 1) = 1$, $X(1, 1) = 0$. In the Operator flow, our Operators are all binary, square Operators (for now).\n",
    "\n",
    "1. **\"Measurements\"** - An $n$-qubit Measurement is a functional taking n-qubit State functions to complex values. For example, a Pauli Z Measurement can be defined by $Z_{meas}(Zero) = 1$ and $Z_{meas}(One) = -1$. Measurements are simply adjoints of State Functions, and can be imagined by quantum mechanics' _bra_ notation (i.e. $Zero_{meas} = Zero^{\\dagger} = \\langle 0|$). In thinking of Measurements as adjoints of State functions, note that $Z_{meas}$ above is equivalent to $1 - 2*(\\langle Zero| + \\langle One|)$.\n",
    "\n",
    "**Throughout this tutorial, we will refer to the mathematical function (of type 1-3 above) that a Python Object represents as that Object's *characteristic function*.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Chaining vs. Composition\n",
    "Note that a chained expression of the functions above can be written in two ways:\n",
    "* As function chaining: $Zero_{meas}(X(Zero))(0) = 0$\n",
    "* As function composition: $Zero_{meas} \\circ Z \\circ X \\circ Zero = 0$\n",
    "\n",
    "In the Operator flow, chaining is used via the `.eval()` method, while composition is used via `.compose()` or `@` (more on this below)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Object Structure\n",
    "\n",
    "The Operator flow includes two primary groups of actors: \n",
    "* Operators, objects which represent functions or functionals, all deriving from `OperatorBase`: \n",
    "    * `PrimitiveOp`s - Basic Operator building blocks, whose behavior are defined by some internal computational primitive from Terra, such as a Terra's `Pauli` (`PauliOp`), `Operator` (`MatrixOp`), or `QuantumCircuit` (`CircuitOp`).\n",
    "    * `StateFn`s - A class for representing both State functions and Measurements, the behavior of which is defined by some internal primitive, e.g. a simple dict (`DictStateFn`), Terra's `Statevector` (`VectorStateFn`), a `QuantumCircuit` (`CircuitStateFn`), or an OperatorBase representing a density operator (`OperatorStateFn`).\n",
    "    * `ListOp`s - Classes for representing composite Operators, State functions, and Measurements constructed from expressions of others, such as addition (`SummedOp`), composition (`ComposedOp`), tensor product (`TensoredOp`), and concatenation into a list (`ListOp`).\n",
    "    * `EvolvedOp` - A special case of a `PrimitiveOp` holding an `Operatorbase` as its primitive, serving as a placeholder for an evolution algorithm to convert later into an Operator approximating the exponentiation of the `OperatorBase`.\n",
    "* Converters, objects which manipulate Operators, all deriving from `ConverterBase`:\n",
    "    * `Expectation`s - Traverse over an Operator and replace `OperatorStateFn` measurements into Z-basis or matrix measurements approximating the expectation value of the measurement.\n",
    "    * `Evolution`s - Traverse over an Operator and replace `EvolvedOp`s with circuits approximating the evolution.\n",
    "    * `CircuitSampler` - Traverse over an Operator and replace `CircuitStateFn`s with `DictStateFn`s approximating them, perhaps sampled from a quantum device.\n",
    "    * Other converters, e.g. `AbelianGrouper`, `PauliBasisChange`\n",
    "    \n",
    "Don't worry if this seems like a whirlwind. We'll discuss each of these in detail in the next section, and you can also find more detail in the [Operator flow API reference](https://qiskit.org/documentation/apidoc/qiskit.aqua.operators.html#module-qiskit.aqua.operators)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Motivating Example\n",
    "\n",
    "Below, we'll show some basic code to highlight the power of the Operator flow. The code is simple - we'll evolve a Bell state by an H2 Hamiltonian using a simple Trotter expansion and measure the energy expectation value of the Hamiltonian at various evolution times. You are obviously not expected to understand it, but inspect it to gain some context and see how it simplifies otherwise complex constructions. Also note that this is a slightly verbose form of this flow for instruction's sake.\n",
    "\n",
    "In the Converters section of this notebook, we'll walk through the example in more detail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.701197Z",
     "start_time": "2020-05-14T11:51:50.669293Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampled Trotterized energies:\n",
      " [-0.67203593 -0.65411556 -0.65320943 -0.6493554  -0.66628234 -0.68088746\n",
      " -0.82303979 -0.91707031]\n"
     ]
    }
   ],
   "source": [
    "from qiskit import BasicAer\n",
    "from qiskit.circuit import Parameter\n",
    "from qiskit.aqua.operators import *\n",
    "import numpy as np\n",
    "\n",
    "two_qubit_H2 =  (-1.0523732 * I^I) + \\\n",
    "                (0.39793742 * I^Z) + \\\n",
    "                (-0.3979374 * Z^I) + \\\n",
    "                (-0.0112801 * Z^Z) + \\\n",
    "                (0.18093119 * X^X)\n",
    "\n",
    "bell = CX @ (Plus^Zero)\n",
    "evo_time = Parameter('θ')\n",
    "evolution_op = (evo_time*two_qubit_H2).exp_i()\n",
    "h2_measurement = StateFn(two_qubit_H2).adjoint()\n",
    "evo_and_meas = h2_measurement @ evolution_op @ bell\n",
    "\n",
    "trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki()).convert(evo_and_meas)\n",
    "diagonalized_meas_op = PauliExpectation().convert(trotterized_op)\n",
    "evo_time_points = list(range(8))\n",
    "h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time: evo_time_points})\n",
    "\n",
    "# Energies by Trotter expansion and sampled measurement\n",
    "sampler = CircuitSampler(backend=BasicAer.get_backend('qasm_simulator'))\n",
    "sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)\n",
    "sampled_trotter_energies = sampled_trotter_exp_op.eval()\n",
    "print('Sampled Trotterized energies:\\n {}'.format(np.real(sampled_trotter_energies)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## State Functions and Measurements\n",
    "\n",
    "The most basic unit of computation in the Operator flow is the state function, abbreviated as `StateFn`, a simple complex function over binary variables. There are several `StateFn` instances built in for convenience, `Zero, One, Plus, Minus`, and four ways a `StateFn` can be defined, `DictStateFn, VectorStateFn, CircuitStateFn, OperatorStateFn`.\n",
    "\n",
    "Every `StateFn` has three properties:\n",
    "* `primitive` - The data structure defining the underlying function's behavior. For `DictStateFn`, this object is a `dict`, etc.\n",
    "* `coeff` - A coefficient multiplying the characteristic function, i.e. `StateFn(my_primitive, coeff=3) == StateFn(my_primitive) * 3`. Note that `coeff` can be int, float, complex or a free `Parameter` object (from `qiskit.circuit` in Terra) to be bound later using `my_op.bind_parameters`.\n",
    "* `is_measurement` - Whether this `StateFn` is a state function or a measurement (remember, a measurement is just the adjoint of a state function)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.706511Z",
     "start_time": "2020-05-14T11:51:55.703542Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.aqua.operators import (StateFn, Zero, One, Plus, Minus, \n",
    "                                   DictStateFn, VectorStateFn, CircuitStateFn, OperatorStateFn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.713336Z",
     "start_time": "2020-05-14T11:51:55.709853Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DictStateFn({'0': 1})\n",
      "DictMeasurement({'0': 1})\n"
     ]
    }
   ],
   "source": [
    "print(Zero)\n",
    "print(Zero.adjoint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The function this object represents, mapping a binary string to a complex value, can be accessed via the `.eval` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.726265Z",
     "start_time": "2020-05-14T11:51:55.715898Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "0.0\n",
      "1.0\n",
      "(0.70710678118655+0j)\n",
      "(-0.70710678118655+0j)\n"
     ]
    }
   ],
   "source": [
    "print(Zero.eval('0'))\n",
    "print(Zero.eval('1'))\n",
    "print(One.eval('1'))\n",
    "print(Plus.eval('0'))\n",
    "print(Minus.eval('1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This should look familiar as something analogous to the quantum state or wavefunctions you know, $|0\\rangle$, $|1\\rangle$, $|+\\rangle$, and $|-\\rangle$, but with a key difference: these statefunctions need not be normalized. `statefunction1 + statefunction2` behaves exactly as you'd expect mathematical functions to behave, producing `statefunction3`, where `statefunction3(x) = statefunction1(x) + statefunction2(x)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.742816Z",
     "start_time": "2020-05-14T11:51:55.728319Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "DictStateFn({'1': 1}) * 3.0\n",
      "(1.4142135623731+0j)\n",
      "0j\n"
     ]
    }
   ],
   "source": [
    "print((One + One + One).eval('1'))\n",
    "print((One + One + One))\n",
    "print((Plus + Minus).eval('0'))\n",
    "print((Plus + Minus).eval('1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The behavior of each StateFn type is defined internally by some data structure, which we call the primitive, and a complex coefficient. The `DictStateFn` is the simplest type, holding a dict primitive of {string: complex} value pairs. `Zero` and `One` are simply these. Any value missing from the dict is simply equal to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.748689Z",
     "start_time": "2020-05-14T11:51:55.744669Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DictStateFn({'0': 1})\n",
      "DictStateFn({'1': 1})\n",
      "{'0': 1}\n",
      "1.0\n",
      "3.0\n",
      "2j\n"
     ]
    }
   ],
   "source": [
    "print(Zero)\n",
    "print(One)\n",
    "print(Zero.primitive)\n",
    "print(Zero.coeff)\n",
    "print((Zero + Zero + Zero).coeff)\n",
    "print((Zero * 2j).coeff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "For simplicity, the `StateFn` class also doubles as the class for Measurement. The adjoint of a `StateFn` is simply a measurement defined by the same primitive as the state. This is conceptually identical to the idea that a bra is the adjoint of a ket, and it is convenient to think of it that way.\n",
    "\n",
    "Just as the State function over binary variables is accessible via `.eval`, so to the Measurement functional over State functions is available via `.eval`. As we'll see below, the availability of the underlying function through `.eval` is also true for the Operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.762592Z",
     "start_time": "2020-05-14T11:51:55.751572Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DictMeasurement({'1': 1})\n",
      "0.0\n",
      "1.0\n",
      "(0.70710678118655+0j)\n"
     ]
    }
   ],
   "source": [
    "print(One.adjoint())\n",
    "print(Zero.adjoint().eval(One))\n",
    "print(Zero.adjoint().eval(Zero))\n",
    "print(Zero.adjoint().eval(Plus))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note that we can also perform function composition between a State function and measure using `.compose`, and call `.eval()` with no argument later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.782168Z",
     "start_time": "2020-05-14T11:51:55.769766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "1.0\n",
      "(0.70710678118655+0j)\n"
     ]
    }
   ],
   "source": [
    "print(Zero.adjoint().compose(One).eval())\n",
    "print(Zero.adjoint().compose(Zero).eval())\n",
    "print(Zero.adjoint().compose(Plus).eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `.eval(state)` vs `.compose(state)`\n",
    "\n",
    "Although they look similar, there is a critical difference between `eval` and `compose`. `eval` will do everything in its power to complete the evaluation, including totally unscalable computation, such as conversion to exponential-sized matrices. Compose will not perform any unscalable computation under the hood, and will simply represent the composition symbolically (returning a `ComposedOp`, see `ListOps` below) if it does not know how to complete the composition efficiently.\n",
    "\n",
    "`eval(state)` can be seen as a convenience for hacking, while `compose` the more typical route for actual usage within quantum algorithms. In some sense, `eval()` will always try to complete the computation its told to complete, and if the computation isn't scalable, it's up you to take more complex steps to make it faster (e.g. run it on a quantum computer)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Arithmetic Operations\n",
    "\n",
    "A rich set of arithmetic operations between StateFns (and all `OperatorBase`s in fact) are supported, including:\n",
    "\n",
    "|Overload|Operation                                                     |\n",
    "|:----:|:---------------------------------------------------------------|\n",
    "| +  | addition                                                      |\n",
    "| -  | subtraction, negation (scalar multiplication by               |\n",
    "| *  | scalar multiplication                                         |\n",
    "| /  | scalar division                                               |\n",
    "| @  | composition                                                   |\n",
    "| ^  | tensor product or tensor power (tensor with self n times)     |\n",
    "| ** | composition power (compose with self n times)                 |\n",
    "| == | equality                                                      |\n",
    "| ~  | adjoint, alternating between a State Function and Measurement |\n",
    "\n",
    "This arithmetic, along with the Operators, allows quick and easy construction of many states for Quantum Algorithms. However, **one must be careful to use parentheses properly when performing arithmetic in this way.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.791102Z",
     "start_time": "2020-05-14T11:51:55.786681Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DictStateFn({'11111': 1.0, '00000': 1.0}) * 600.0\n",
      "DictStateFn({'101010': 1})\n"
     ]
    }
   ],
   "source": [
    "print(600 * ((One^5) + (Zero^5)))\n",
    "print(One^Zero^3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "States can also be easily converted between primitives. Below we'll see that we can also represent State functions by vectors and Quantum circuits. Note that to be consistent with the Operators, we use `to_matrix_op` to convert to a `VectorStateFn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T12:25:02.431401Z",
     "start_time": "2020-05-14T12:25:02.406096Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VectorStateFn(Statevector([ 0.25-0.j, -0.25+0.j,  0.25-0.j, -0.25+0.j, -0.25+0.j,\n",
      "              0.25-0.j, -0.25+0.j,  0.25-0.j,  0.25-0.j, -0.25+0.j,\n",
      "              0.25-0.j, -0.25+0.j, -0.25+0.j,  0.25-0.j, -0.25+0.j,\n",
      "              0.25-0.j],\n",
      "            dims=(2, 2, 2, 2)))\n",
      "CircuitStateFn(\n",
      "     ┌───┐\n",
      "q_0: ┤ X ├\n",
      "     ├───┤\n",
      "q_1: ┤ H ├\n",
      "     ├───┤\n",
      "q_2: ┤ X ├\n",
      "     ├───┤\n",
      "q_3: ┤ H ├\n",
      "     └───┘\n",
      ")\n",
      "CircuitStateFn(\n",
      "     ┌──────────────────────────────────────────────────────┐\n",
      "q_0: ┤0                                                     ├\n",
      "     │                                                      │\n",
      "q_1: ┤1                                                     ├\n",
      "     │  initialize(0,0,0,0,0,0.5,0,0.5,0,0,0,0,0,0.5,0,0.5) │\n",
      "q_2: ┤2                                                     ├\n",
      "     │                                                      │\n",
      "q_3: ┤3                                                     ├\n",
      "     └──────────────────────────────────────────────────────┘\n",
      ") * 1.000000000000007\n"
     ]
    }
   ],
   "source": [
    "print(((Plus^Minus)^2).to_matrix_op())\n",
    "# TODO round\n",
    "print(((Plus^One)^2).to_circuit_op())\n",
    "print(((Plus^One)^2).to_matrix_op().to_circuit_op())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In fact, `Plus` and `Minus` are `CircuitStateFn`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.834154Z",
     "start_time": "2020-05-14T11:51:55.827086Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CircuitStateFn(\n",
      "     ┌───┐\n",
      "q_0: ┤ H ├\n",
      "     └───┘\n",
      ")\n",
      "CircuitStateFn(\n",
      "     ┌───┐┌───┐\n",
      "q_0: ┤ X ├┤ H ├\n",
      "     └───┘└───┘\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(Plus)\n",
    "print(Minus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Constructing a `StateFn` is easy. The `StateFn` class also serves as a factory, and can take any applicable primitive in its constructor and return the correct `StateFn` subclass. Right now the following primitives can be passed into the constructor, listed alongside the `StateFn` subclass they produce:\n",
    "\n",
    "* `str` (equal to some basis bitstring) → `DictStateFn`\n",
    "* `dict` → `DictStateFn`\n",
    "* Qiskit `Result` object → `DictStateFn`\n",
    "* `list` → `VectorStateFn`\n",
    "* `np.ndarray` → `VectorStateFn`\n",
    "* Terra's `quantum_info.Statevector` → `VectorStateFn`\n",
    "* `QuantumCircuit` → `CircuitStateFn`\n",
    "* `Instruction` → `CircuitStateFn`\n",
    "* `OperatorBase` → `OperatorStateFn`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.854813Z",
     "start_time": "2020-05-14T11:51:55.837390Z"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DictStateFn({'0': 1})\n",
      "True\n",
      "VectorStateFn(Statevector([0.+0.j, 1.+0.j, 1.+0.j, 0.+0.j],\n",
      "            dims=(2, 2)))\n",
      "CircuitStateFn(\n",
      "     ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐\n",
      "q_0: ┤ RY(θ[0]) ├──■──┤ RY(θ[2]) ├──■──┤ RY(θ[4]) ├──■──┤ RY(θ[6]) ├\n",
      "     ├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤\n",
      "q_1: ┤ RY(θ[1]) ├┤ X ├┤ RY(θ[3]) ├┤ X ├┤ RY(θ[5]) ├┤ X ├┤ RY(θ[7]) ├\n",
      "     └──────────┘└───┘└──────────┘└───┘└──────────┘└───┘└──────────┘\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(StateFn({'0':1}))\n",
    "print(StateFn({'0':1}) == Zero)\n",
    "\n",
    "print(StateFn([0,1,1,0]))\n",
    "\n",
    "from qiskit.circuit.library import RealAmplitudes\n",
    "print(StateFn(RealAmplitudes(2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## PrimitiveOps\n",
    "\n",
    "Operators are functions which take StateFns to StateFns, and `PrimitiveOp`s are the building blocks for these Objects. For example, the identity Operator takes any StateFn to itself, and we can build this Operator efficiently out of `PauliOps`. Just like State Functions and Measurements, this characteristic function of the Operator is accessible via the `.eval` method, and the behavior of the function is defined by a computational primitive. If you pass a bitstring into an Operator's `eval` function, it will simply treat it as the corresponding basis StateFn.\n",
    "\n",
    "Every `PrimitiveOp` has two properties:\n",
    "* `primitive` - The data structure defining the underlying function's behavior. For `CircuitOp`, this object is a `QuantumCircuit`, etc.\n",
    "* `coeff` - A coefficient multiplying the characteristic function. Note that `coeff` can be int, float, complex or a free `Parameter` object (from `qiskit.circuit` in Terra) to be bound later using `my_op.bind_parameters`.\n",
    "\n",
    "Just like StateFn, `PrimitiveOp` is also a factory for creating the correct type of `PrimitiveOp` for a given primitive. Right now the following primitives can be passed into the constructor, listed alongside the `PrimitiveOp` subclass they produce:\n",
    "\n",
    "* Terra's `Pauli` → `PauliOp`\n",
    "* `Instruction` → `CircuitOp`\n",
    "* `QuantumCircuit` → `CircuitOp`\n",
    "* 2d `list` → `MatrixOp`\n",
    "* `np.ndarray` → `MatrixOp`\n",
    "* `scipy.spmatrix` → `MatrixOp`\n",
    "* Terra's `quantum_info.Operator` → `MatrixOp`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.863950Z",
     "start_time": "2020-05-14T11:51:55.857643Z"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.aqua.operators import X, Y, Z, I, CX, T, H, S, PrimitiveOp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T12:28:00.875004Z",
     "start_time": "2020-05-14T12:28:00.844861Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X\n",
      "DictStateFn({'0': (1+0j)})\n",
      "True\n",
      "DictStateFn({'0': (1+0j)}) * 3.0\n",
      "          \n",
      "q_0: ──■──\n",
      "     ┌─┴─┐\n",
      "q_1: ┤ X ├\n",
      "     └───┘\n",
      "VectorStateFn(Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],\n",
      "            dims=(2, 2)))\n",
      "(1+0j)\n",
      "(1+0j)\n",
      "          ┌───┐          ┌───┐     \n",
      "q_0: ──■──┤ H ├───────■──┤ H ├─────\n",
      "     ┌─┴─┐└───┘┌───┐┌─┴─┐└───┘┌───┐\n",
      "q_1: ┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├\n",
      "     └───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤\n",
      "q_2: ──■──┤ X ├┤ H ├──■──┤ X ├┤ H ├\n",
      "     ┌─┴─┐└───┘├───┤┌─┴─┐└───┘├───┤\n",
      "q_3: ┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├\n",
      "     └───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤\n",
      "q_4: ─────┤ X ├┤ H ├─────┤ X ├┤ H ├\n",
      "          └───┘└───┘     └───┘└───┘\n"
     ]
    }
   ],
   "source": [
    "print(X)\n",
    "print(X.eval(One))\n",
    "print(X.eval(One) == Zero)\n",
    "print(3*X.eval(One))\n",
    "\n",
    "print(CX)\n",
    "print(CX.eval('01'))\n",
    "print(CX.eval('01').eval('11'))\n",
    "# The same expression, written in compositions:\n",
    "print(((~One^2) @ CX @ (Zero^One)).eval())\n",
    "\n",
    "# We can build complicated Operators very easily\n",
    "print(((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Some important notes:**\n",
    "* Qiskit prints circuits in small-endianness, meaning that qubit 0 in the Operator construction will print at the **bottom** of the circuit. \n",
    "* Circuits grow left to right, with the state beginning to the left, whereas mathematical notation grows right to left, with the starting state to the right. For this reason, circuits will appear to print in reverse from how you've constructed them.\n",
    "* We can convert a `CircuitOp` into `CircuitStateFn` simply by composing `Zero` or another `CircuitStateFn`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.941125Z",
     "start_time": "2020-05-14T11:51:55.903565Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               \n",
      "q_0: ──────────\n",
      "               \n",
      "q_1: ──────────\n",
      "     ┌───┐┌───┐\n",
      "q_2: ┤ X ├┤ H ├\n",
      "     └───┘└───┘\n",
      "CircuitStateFn(\n",
      "     ┌───┐┌───┐     ┌───┐          ┌───┐     \n",
      "q_0: ┤ X ├┤ H ├──■──┤ H ├───────■──┤ H ├─────\n",
      "     ├───┤├───┤┌─┴─┐└───┘┌───┐┌─┴─┐└───┘┌───┐\n",
      "q_1: ┤ X ├┤ H ├┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├\n",
      "     ├───┤├───┤└───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤\n",
      "q_2: ┤ X ├┤ H ├──■──┤ X ├┤ H ├──■──┤ X ├┤ H ├\n",
      "     ├───┤├───┤┌─┴─┐└───┘├───┤┌─┴─┐└───┘├───┤\n",
      "q_3: ┤ X ├┤ H ├┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├\n",
      "     ├───┤├───┤└───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤\n",
      "q_4: ┤ X ├┤ H ├─────┤ X ├┤ H ├─────┤ X ├┤ H ├\n",
      "     └───┘└───┘     └───┘└───┘     └───┘└───┘\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(((H^I^I)@(X^I^I)))\n",
    "\n",
    "# Note that this is now printed as a `CircuitStateFn`!\n",
    "print((((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2) @ (Minus^5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`PrimitiveOp`s enjoy the same rich set of arithmetic operations and conversion options as the `StateFn`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:55.971213Z",
     "start_time": "2020-05-14T11:51:55.943646Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operator([[ 1.-0.j,  0.+0.j,  0.+0.j,  0.+0.j],\n",
      "          [ 0.+0.j,  1.-0.j,  0.+0.j,  0.+0.j],\n",
      "          [ 0.+0.j,  0.+0.j,  1.-0.j,  0.+0.j],\n",
      "          [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]],\n",
      "         input_dims=(2, 2), output_dims=(2, 2))\n",
      "     ┌──────────┐\n",
      "q_0: ┤0         ├\n",
      "     │  unitary │\n",
      "q_1: ┤1         ├\n",
      "     └──────────┘\n",
      "SummedOp(\n",
      "[0.5 * II,\n",
      "0.5 * IZ,\n",
      "0.5 * ZI,\n",
      "-0.5 * ZZ])\n"
     ]
    }
   ],
   "source": [
    "circ_op = (H^I) @ CX @ (H^I)\n",
    "mat_op = circ_op.to_matrix_op()\n",
    "print(mat_op)\n",
    "print(mat_op.to_circuit_op()) # attempt to convert back to circuit, will use a `UnitaryGate`\n",
    "print(circ_op.to_pauli_op()) # convert to sum of Paulis, more on `SummedOp`s below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `OperatorStateFn`\n",
    "\n",
    "There is a special type of `StateFn` which we did not discuss above, called an `OperatorStateFn`, whose behavior is defined by an `OperatorBase` density operator. As a measurement, this is equivalent to an expectation measurement by an `OperatorBase` observable. Note that measurement case is by far the more common usage of this Class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T12:31:29.539627Z",
     "start_time": "2020-05-14T12:31:29.518356Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OperatorStateFn(Z)\n",
      "OperatorMeasurement(Z)\n",
      "(1+0j)\n",
      "0j\n",
      "(1+0j)\n",
      "(-1.06365328+0j)\n"
     ]
    }
   ],
   "source": [
    "print(StateFn(Z))\n",
    "print(~StateFn(Z))\n",
    "\n",
    "print(StateFn(Z).adjoint().eval(Zero))\n",
    "print(StateFn(Z).adjoint().eval(Plus))\n",
    "\n",
    "# Note that Pauli measurements of `DictStateFns` are done by bitwise operations under the hood,\n",
    "# so they can be huge. Here's a 400-qubit measurement:\n",
    "print(StateFn(Z^400).adjoint().eval((One^Zero)^200))\n",
    "\n",
    "# We can construct expectation values this way, but can't always perform them efficiently. \n",
    "# See `Expectations` below.\n",
    "two_qubit_H2 =  (-1.0523732 * I^I) + \\\n",
    "                (0.39793742 * I^Z) + \\\n",
    "                (-0.3979374 * Z^I) + \\\n",
    "                (-0.0112801 * Z^Z) + \\\n",
    "                (0.18093119 * X^X)\n",
    "print(StateFn(two_qubit_H2).adjoint().eval(Zero^Zero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ListOps\n",
    "\n",
    "If you've already played around with the above, you'll notice that you can easily perform operations between `OperatorBase`s which we may not know how to perform efficiently in general (or simply haven't implemented an efficient procedure for yet), such as addition between `CircuitOp`s. In those cases, you may receive a `ListOp` result (or subclass thereof) from your operation representing the lazy execution of the operation. For example, if you attempt to add together a `DictStateFn` and a `CircuitStateFn`, you'll receive a `SummedOp` representing the sum of the two. This composite State function still has a working `eval` (but may need to perform a non-scalable computation under the hood, such as converting both to vectors).\n",
    "\n",
    "These composite `OperatorBase`s are how we construct increasingly complex and rich computation out of `PrimitiveOp` and `StateFn` building blocks.\n",
    "\n",
    "Every `ListOp` has four properties:\n",
    "* `oplist` - The list of `OperatorBase`s which define the behavior of the `ListOp`'s characteristic function.\n",
    "* `combo_fn` - The function taking a list of classical scalars to an output value which defines how to combine the outputs of the `oplist` items' functions to produce the `ListOp`'s characteristic function. For broadcasting simplicity, this function is defined over NumPy arrays.\n",
    "* `coeff` - A coefficient multiplying the characteristic function. Note that `coeff` can be int, float, complex or a free `Parameter` object (from `qiskit.circuit` in Terra) to be bound later using `my_op.bind_parameters`.\n",
    "* `abelian` - Indicates whether the Operators in `oplist` are known to mutually commute (usually set after being converted by the `AbelianGrouper` converter).\n",
    "\n",
    "Note that `ListOp` supports typical iteration overloads, so you can use indexing like `my_op[4]` to access the `OperatorBase`s in `oplist`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.011011Z",
     "start_time": "2020-05-14T11:51:56.003384Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SummedOp(\n",
      "[DictStateFn({'0': 1}),\n",
      "CircuitStateFn(\n",
      "     ┌───┐\n",
      "q_0: ┤ H ├\n",
      "     └───┘\n",
      ")])\n",
      "DictStateFn({'0': 1})\n",
      "(1.7071067811865501+0j)\n"
     ]
    }
   ],
   "source": [
    "print(Zero + Plus)\n",
    "print((Zero + Plus)[0])\n",
    "print((Zero + Plus).eval('0'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Or for composition, you might receive a `ComposedOp`. Note that just as in addition, we can sometimes perform the composition efficiently, such as between two circuit State functions. However, when composing a Measurement with a State function, we will always receive a `ComposedOp` back to reflect the fact that the State Function has been measured."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.027891Z",
     "start_time": "2020-05-14T11:51:56.013142Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dict measurement with Circuit statefn:\n",
      "ComposedOp(\n",
      "[DictMeasurement({'1': 1}),\n",
      "CircuitStateFn(\n",
      "     ┌───┐┌───┐\n",
      "q_0: ┤ X ├┤ H ├\n",
      "     └───┘└───┘\n",
      ")])\n",
      "(-0.70710678118655-0j)\n",
      "\n",
      "Circuit measurement with Circuit statefn:\n",
      "ComposedOp(\n",
      "[CircuitMeasurement(\n",
      "     ┌───┐┌───┐┌───┐\n",
      "q_0: ┤ X ├┤ H ├┤ X ├\n",
      "     └───┘└───┘└───┘\n",
      "),\n",
      "DictStateFn({'0': 1})])\n",
      "\n",
      "Dict measurement with vector statefn:\n",
      "ComposedOp(\n",
      "[DictMeasurement({'1': 1}),\n",
      "VectorStateFn(Statevector([ 0.70710678-0.j, -0.70710678+0.j],\n",
      "            dims=(2,)))])\n"
     ]
    }
   ],
   "source": [
    "print('Dict measurement with Circuit statefn:')\n",
    "print(~One @ Minus)\n",
    "print((~One @ Minus).eval())\n",
    "print('\\nCircuit measurement with Circuit statefn:')\n",
    "print(~One.to_circuit_op() @ Minus)\n",
    "print('\\nDict measurement with vector statefn:')\n",
    "print(~One @ Minus.to_matrix_op())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Hierarchical ListOps\n",
    "\n",
    "The base `ListOp` class is a special type of ListOp. Its `combo_fn` is the identity - it accepts a list and produces that same list. This allows the ListOp's characteristic function to represent the vectorization of the `oplist`'s characteristic functions into a list, and the construction of large and interesting Operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.068090Z",
     "start_time": "2020-05-14T11:51:56.031447Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(-1+0j), (1+0j), 0j, 0j]\n",
      "[[-1.+0.j  1.+0.j  0.+0.j  0.+0.j]\n",
      " [ 0.+0.j  0.+0.j  1.+0.j -1.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "print((~StateFn(Z) @ ListOp([One, Zero, Plus, Minus])).eval())\n",
    "print(np.asarray((~StateFn(ListOp([Z, X])) @ ListOp([One, Zero, Plus, Minus])).eval()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "For example, building a Quantum Kernel is trivial using `ListOp`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.115377Z",
     "start_time": "2020-05-14T11:51:56.070088Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.        +0.j  0.        +0.j  0.70710678+0.j -0.70710678-0.j]\n",
      " [ 0.        +0.j  1.        +0.j  0.70710678+0.j  0.70710678+0.j]\n",
      " [ 0.70710678+0.j  0.70710678+0.j  1.        +0.j  0.        +0.j]\n",
      " [-0.70710678+0.j  0.70710678+0.j  0.        +0.j  1.        +0.j]]\n"
     ]
    }
   ],
   "source": [
    "kernel_states = ListOp([One, Zero, Plus, Minus])\n",
    "print(np.asarray((~kernel_states @ kernel_states).eval()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note that in contrast with Terra, binding a list of values to a parameter in `bind_parameters` will return a `ListOp` of copies of the Operator bound with each parameterization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.192334Z",
     "start_time": "2020-05-14T11:51:56.117528Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ListOp(\n",
      "[CircuitStateFn(\n",
      "     ┌───┐┌────────────┐                        ┌───┐┌────────────┐     »\n",
      "q_0: ┤ H ├┤ U1(1.3658) ├──■──────────────────■──┤ H ├┤ U1(1.3658) ├──■──»\n",
      "     ├───┤├────────────┤┌─┴─┐┌────────────┐┌─┴─┐├───┤├────────────┤┌─┴─┐»\n",
      "q_1: ┤ H ├┤ U1(1.4331) ├┤ X ├┤ U1(11.925) ├┤ X ├┤ H ├┤ U1(1.4331) ├┤ X ├»\n",
      "     └───┘└────────────┘└───┘└────────────┘└───┘└───┘└────────────┘└───┘»\n",
      "«                        \n",
      "«q_0: ────────────────■──\n",
      "«     ┌────────────┐┌─┴─┐\n",
      "«q_1: ┤ U1(11.925) ├┤ X ├\n",
      "«     └────────────┘└───┘\n",
      "),\n",
      "CircuitStateFn(\n",
      "     ┌───┐┌──────────────┐                        ┌───┐┌──────────────┐     »\n",
      "q_0: ┤ H ├┤ U1(0.091785) ├──■──────────────────■──┤ H ├┤ U1(0.091785) ├──■──»\n",
      "     ├───┤└┬────────────┬┘┌─┴─┐┌────────────┐┌─┴─┐├───┤└┬────────────┬┘┌─┴─┐»\n",
      "q_1: ┤ H ├─┤ U1(1.2746) ├─┤ X ├┤ U1(15.505) ├┤ X ├┤ H ├─┤ U1(1.2746) ├─┤ X ├»\n",
      "     └───┘ └────────────┘ └───┘└────────────┘└───┘└───┘ └────────────┘ └───┘»\n",
      "«                        \n",
      "«q_0: ────────────────■──\n",
      "«     ┌────────────┐┌─┴─┐\n",
      "«q_1: ┤ U1(15.505) ├┤ X ├\n",
      "«     └────────────┘└───┘\n",
      ")])\n",
      "[[1.         0.66043684]\n",
      " [0.66043684 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "from qiskit.circuit.library import ZZFeatureMap\n",
    "feat_map = PrimitiveOp(ZZFeatureMap(2)) @ Zero\n",
    "mapped_features = feat_map.bind_parameters(dict(zip(feat_map.primitive.ordered_parameters, np.random.random((2,2)).tolist())))\n",
    "qkernel_mat = (~mapped_features @ mapped_features).eval()\n",
    "\n",
    "print(mapped_features)\n",
    "print(np.abs(qkernel_mat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converters\n",
    "\n",
    "Converters traverse an Operator structure and perform a particular manipulation or replacement, defined by the converter's `convert()` method, of the Operators within. Typically, if a converter encounters an `OperatorBase` in the recursion which is irrelevant to its conversion purpose, that `OperatorBase` is left alone. Let's go back to our example from the top of this notebook to see the core converters in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.202317Z",
     "start_time": "2020-05-14T11:51:56.198083Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit.aqua.operators import I, X, Y, Z, H, CX, Zero, ListOp, PauliExpectation, PauliTrotterEvolution, CircuitSampler, MatrixEvolution\n",
    "from qiskit.circuit import Parameter\n",
    "from qiskit import BasicAer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Evolutions, `exp_i()`, and the `EvolvedOp`\n",
    "\n",
    "Every `PrimitiveOp` and `ListOp` has an `.exp_i()` function to perform its Schrödinger-style exponentiation, $e^{-iHt}$. In practice, only a few of these Operators have an efficiently computable exponentiation (such as MatrixOp and the PauliOps with only one non-identity single-qubit Pauli), so we need to return a placeholder (similar to how `SummedOp` is a placeholder when we can't perform addition). This placeholder is called `EvolvedOp`, and it holds the `OperatorBase` to be exponentiated in its `.primitive` property.\n",
    "\n",
    "Operator flow fully supports parameterization, so we can use a `Parameter` for our evolution time here. Notice that there's no \"evolution time\" argument in any function. The Operator flow exponentiates whatever operator we tell it to, and if we choose to multiply the operator by an evolution time, $e^{-iHt}$, that will be reflected in our exponentiation parameters. This is not some trick to make it look like Physics - it actually works this way under the hood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T12:38:07.733251Z",
     "start_time": "2020-05-14T12:38:07.726139Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e^(-i*1.0*θ * SummedOp(\n",
      "[-1.0523732 * II,\n",
      "0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ,\n",
      "0.18093119 * XX]))\n",
      "EvolvedOp(SummedOp([PauliOp(Pauli(z=[False, False], x=[False, False]), coeff=-1.0523732), PauliOp(Pauli(z=[True, False], x=[False, False]), coeff=0.39793742), PauliOp(Pauli(z=[False, True], x=[False, False]), coeff=-0.3979374), PauliOp(Pauli(z=[True, True], x=[False, False]), coeff=-0.0112801), PauliOp(Pauli(z=[False, False], x=[True, True]), coeff=0.18093119)], coeff=1.0*θ, abelian=False), coeff=1.0)\n"
     ]
    }
   ],
   "source": [
    "two_qubit_H2 =  (-1.0523732 * I^I) + \\\n",
    "                (0.39793742 * I^Z) + \\\n",
    "                (-0.3979374 * Z^I) + \\\n",
    "                (-0.0112801 * Z^Z) + \\\n",
    "                (0.18093119 * X^X)\n",
    "evo_time = Parameter('θ')\n",
    "\n",
    "evolution_op = (evo_time*two_qubit_H2).exp_i()\n",
    "print(evolution_op) # Note, EvolvedOps print as exponentiations\n",
    "print(repr(evolution_op))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Now construct the energy measurement, (as discussed in [the `OperatorStateFn` section](#OperatorStateFn) above), and compose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T12:38:15.820502Z",
     "start_time": "2020-05-14T12:38:15.813958Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ComposedOp(\n",
      "[OperatorMeasurement(SummedOp(\n",
      "[-1.0523732 * II,\n",
      "0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ,\n",
      "0.18093119 * XX])),\n",
      "e^(-i*1.0*θ * SummedOp(\n",
      "[-1.0523732 * II,\n",
      "0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ,\n",
      "0.18093119 * XX])),\n",
      "CircuitStateFn(\n",
      "               \n",
      "q_0: ───────■──\n",
      "     ┌───┐┌─┴─┐\n",
      "q_1: ┤ H ├┤ X ├\n",
      "     └───┘└───┘\n",
      ")])\n"
     ]
    }
   ],
   "source": [
    "h2_measurement = StateFn(two_qubit_H2).adjoint()\n",
    "\n",
    "bell = CX @ (H^I) @ Zero\n",
    "# We can also do CX @ (Plus ^ Zero)\n",
    "evo_and_meas = h2_measurement @ evolution_op @ bell\n",
    "print(evo_and_meas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`Evolution`s are converters which traverse an Operator tree, replacing any `EvolvedOp` with a Schrödinger equation-style evolution `CircuitOp` equaling or approximating the matrix exponential of -i * the `OperatorBase` contained inside the `EvolvedOp` (`evo_op.primitive`). The Evolutions are essentially implementations of Hamiltonian Simulation algorithms, including various methods for Trotterization.\n",
    "\n",
    "We can use an `Evolution` converter to convert `EvolvedOp`s into `CircuitOp`s. The `PauliTrotterEvolution` will convert the Operator to be evolved into a sum of `PauliOp`s and use Trotterization to produce a circuit, and `MatrixEvolution` will convert to a `MatrixOp` and produce a circuit using Terra's `HamiltonianGate` (which is classical exponentiation under the hood). \n",
    "\n",
    "Note that below, evolution time parameter θ has flowed into the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.257411Z",
     "start_time": "2020-05-14T11:51:56.226479Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ComposedOp(\n",
      "[OperatorMeasurement(SummedOp(\n",
      "[-1.0523732 * II,\n",
      "0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ,\n",
      "0.18093119 * XX])),\n",
      "CircuitStateFn(\n",
      "               ┌───┐┌───┐┌───────────────────┐┌───┐┌───┐┌───┐»\n",
      "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├┤ X ├»\n",
      "     ┌───┐┌─┴─┐├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤└─┬─┘»\n",
      "q_1: ┤ H ├┤ X ├┤ H ├──■─────────────────────────■──┤ H ├──■──»\n",
      "     └───┘└───┘└───┘                               └───┘     »\n",
      "«     ┌───────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ RZ(0.19896871*θ) ├┤ RZ(0.19896871*θ) ├┤ X ├»\n",
      "«     └───────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»\n",
      "«q_1: ───────────────────────■──┤ RZ(-0.1989687*θ) ├┤ RZ(-0.1989687*θ) ├──■──»\n",
      "«                               └──────────────────┘└──────────────────┘     »\n",
      "«     ┌───────────────────┐┌───┐┌───┐┌───┐┌───────────────────┐┌───┐┌───┐\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├\n",
      "«     └───────────────────┘└─┬─┘├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤\n",
      "«q_1: ───────────────────────■──┤ H ├──■─────────────────────────■──┤ H ├\n",
      "«                               └───┘                               └───┘\n",
      ")])\n"
     ]
    }
   ],
   "source": [
    "trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=1)).convert(evo_and_meas)\n",
    "# We can also set trotter_mode='suzuki' or leave it empty to default to first order Trotterization.\n",
    "print(trotterized_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can bind our parameter to the operator if we so choose, and it will recursively bind into the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.273969Z",
     "start_time": "2020-05-14T11:51:56.259219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">               ┌───┐┌───┐┌──────────────┐┌───┐┌───┐┌───┐┌──────────────┐┌───┐»\n",
       "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0.045233) ├┤ X ├┤ H ├┤ X ├┤ RZ(-0.00282) ├┤ X ├»\n",
       "     ┌───┐┌─┴─┐├───┤└─┬─┘└──────────────┘└─┬─┘├───┤└─┬─┘└──────────────┘└─┬─┘»\n",
       "q_1: ┤ H ├┤ X ├┤ H ├──■────────────────────■──┤ H ├──■────────────────────■──»\n",
       "     └───┘└───┘└───┘                          └───┘                          »\n",
       "«      ┌──────────────┐ ┌──────────────┐┌───┐┌──────────────┐┌───┐┌───┐┌───┐»\n",
       "«q_0: ─┤ RZ(0.099484) ├─┤ RZ(0.099484) ├┤ X ├┤ RZ(-0.00282) ├┤ X ├┤ H ├┤ X ├»\n",
       "«     ┌┴──────────────┤┌┴──────────────┤└─┬─┘└──────────────┘└─┬─┘├───┤└─┬─┘»\n",
       "«q_1: ┤ RZ(-0.099484) ├┤ RZ(-0.099484) ├──■────────────────────■──┤ H ├──■──»\n",
       "«     └───────────────┘└───────────────┘                          └───┘     »\n",
       "«     ┌──────────────┐┌───┐┌───┐\n",
       "«q_0: ┤ RZ(0.045233) ├┤ X ├┤ H ├\n",
       "«     └──────────────┘└─┬─┘├───┤\n",
       "«q_1: ──────────────────■──┤ H ├\n",
       "«                          └───┘</pre>"
      ],
      "text/plain": [
       "               ┌───┐┌───┐┌──────────────┐┌───┐┌───┐┌───┐┌──────────────┐┌───┐»\n",
       "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0.045233) ├┤ X ├┤ H ├┤ X ├┤ RZ(-0.00282) ├┤ X ├»\n",
       "     ┌───┐┌─┴─┐├───┤└─┬─┘└──────────────┘└─┬─┘├───┤└─┬─┘└──────────────┘└─┬─┘»\n",
       "q_1: ┤ H ├┤ X ├┤ H ├──■────────────────────■──┤ H ├──■────────────────────■──»\n",
       "     └───┘└───┘└───┘                          └───┘                          »\n",
       "«      ┌──────────────┐ ┌──────────────┐┌───┐┌──────────────┐┌───┐┌───┐┌───┐»\n",
       "«q_0: ─┤ RZ(0.099484) ├─┤ RZ(0.099484) ├┤ X ├┤ RZ(-0.00282) ├┤ X ├┤ H ├┤ X ├»\n",
       "«     ┌┴──────────────┤┌┴──────────────┤└─┬─┘└──────────────┘└─┬─┘├───┤└─┬─┘»\n",
       "«q_1: ┤ RZ(-0.099484) ├┤ RZ(-0.099484) ├──■────────────────────■──┤ H ├──■──»\n",
       "«     └───────────────┘└───────────────┘                          └───┘     »\n",
       "«     ┌──────────────┐┌───┐┌───┐\n",
       "«q_0: ┤ RZ(0.045233) ├┤ X ├┤ H ├\n",
       "«     └──────────────┘└─┬─┘├───┤\n",
       "«q_1: ──────────────────■──┤ H ├\n",
       "«                          └───┘"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bound = trotterized_op.bind_parameters({evo_time: .5})\n",
    "# Note bound is a `ComposedOp`, so here we are indexing [1] to just view the `CircuitOp`\n",
    "bound[1].to_circuit().draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Expectations\n",
    "\n",
    "`Expectation`s are converters which enable the computation of expectation values of Observables. They traverse an Operator tree, replacing `OperatorStateFn` measurements with equivalent measurements which are more amenable to\n",
    "computation on quantum or classical hardware. For example, if we want to measure the expectation value of an Operator `o` expressed as a sum of Paulis with respect to some state function, but can only access diagonal measurements on Quantum hardware, we can create a measurement ~StateFn(o), use a ``PauliExpectation`` to convert it to a diagonal measurement and circuit pre-rotations to append to the state.\n",
    "\n",
    "Another interesting `Expectation` is the `AerPauliExpectation`, which converts the measurement into a `CircuitStateFn` containing a special expectation snapshot instruction which `Aer` can execute natively with high performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.282981Z",
     "start_time": "2020-05-14T11:51:56.275766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SummedOp(\n",
      "[ComposedOp(\n",
      "[OperatorMeasurement(-1.0523732 * II),\n",
      "II]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(0.39793742 * IZ),\n",
      "II]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(-0.3979374 * ZI),\n",
      "II]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(-0.0112801 * ZZ),\n",
      "II]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(0.18093119 * ZZ),\n",
      "     ┌───┐\n",
      "q_0: ┤ H ├\n",
      "     ├───┤\n",
      "q_1: ┤ H ├\n",
      "     └───┘])])\n"
     ]
    }
   ],
   "source": [
    "# Note that XX was the only non-diagonal measurement in our H2 Observable\n",
    "print(PauliExpectation(group_paulis=False).convert(h2_measurement))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "By default `group_paulis=True`, which will use the `AbelianGrouper` to convert the `SummedOp` into groups of mutually-commuting Paulis. This reduced circuit execution overhead, as each group can share the same circuit execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.292292Z",
     "start_time": "2020-05-14T11:51:56.284850Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SummedOp(\n",
      "[ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.18093119 * ZZ,\n",
      "-1.0523732 * II])),\n",
      "     ┌───┐\n",
      "q_0: ┤ H ├\n",
      "     ├───┤\n",
      "q_1: ┤ H ├\n",
      "     └───┘]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ])),\n",
      "II])])\n"
     ]
    }
   ],
   "source": [
    "print(PauliExpectation().convert(h2_measurement))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note that converters act recursively, so we can just convert our full evolution and measurement expression. We could have equally composed the converted `h2_measurement` with our evolution `CircuitStateFn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.314462Z",
     "start_time": "2020-05-14T11:51:56.294191Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SummedOp(\n",
      "[ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.18093119 * ZZ,\n",
      "-1.0523732 * II])),\n",
      "CircuitStateFn(\n",
      "               ┌───┐┌───┐┌───────────────────┐┌───┐┌───┐┌───┐»\n",
      "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├┤ X ├»\n",
      "     ┌───┐┌─┴─┐├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤└─┬─┘»\n",
      "q_1: ┤ H ├┤ X ├┤ H ├──■─────────────────────────■──┤ H ├──■──»\n",
      "     └───┘└───┘└───┘                               └───┘     »\n",
      "«     ┌───────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ RZ(0.19896871*θ) ├┤ RZ(0.19896871*θ) ├┤ X ├»\n",
      "«     └───────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»\n",
      "«q_1: ───────────────────────■──┤ RZ(-0.1989687*θ) ├┤ RZ(-0.1989687*θ) ├──■──»\n",
      "«                               └──────────────────┘└──────────────────┘     »\n",
      "«     ┌───────────────────┐┌───┐┌───┐┌───┐┌───────────────────┐┌───┐┌───┐┌───┐\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├┤ H ├\n",
      "«     └───────────────────┘└─┬─┘├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤├───┤\n",
      "«q_1: ───────────────────────■──┤ H ├──■─────────────────────────■──┤ H ├┤ H ├\n",
      "«                               └───┘                               └───┘└───┘\n",
      ")]),\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.39793742 * IZ,\n",
      "-0.3979374 * ZI,\n",
      "-0.0112801 * ZZ])),\n",
      "CircuitStateFn(\n",
      "               ┌───┐┌───┐┌───────────────────┐┌───┐┌───┐┌───┐»\n",
      "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├┤ X ├»\n",
      "     ┌───┐┌─┴─┐├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤└─┬─┘»\n",
      "q_1: ┤ H ├┤ X ├┤ H ├──■─────────────────────────■──┤ H ├──■──»\n",
      "     └───┘└───┘└───┘                               └───┘     »\n",
      "«     ┌───────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ RZ(0.19896871*θ) ├┤ RZ(0.19896871*θ) ├┤ X ├»\n",
      "«     └───────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»\n",
      "«q_1: ───────────────────────■──┤ RZ(-0.1989687*θ) ├┤ RZ(-0.1989687*θ) ├──■──»\n",
      "«                               └──────────────────┘└──────────────────┘     »\n",
      "«     ┌───────────────────┐┌───┐┌───┐┌───┐┌───────────────────┐┌───┐┌───┐\n",
      "«q_0: ┤ RZ(-0.00564005*θ) ├┤ X ├┤ H ├┤ X ├┤ RZ(0.090465595*θ) ├┤ X ├┤ H ├\n",
      "«     └───────────────────┘└─┬─┘├───┤└─┬─┘└───────────────────┘└─┬─┘├───┤\n",
      "«q_1: ───────────────────────■──┤ H ├──■─────────────────────────■──┤ H ├\n",
      "«                               └───┘                               └───┘\n",
      ")])])\n"
     ]
    }
   ],
   "source": [
    "diagonalized_meas_op = PauliExpectation().convert(trotterized_op)\n",
    "print(diagonalized_meas_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "And now, we shard even further by binding with multiple parameters into a `ListOp`. Now that we've bound our parameters, we can already used `eval` (we could have used it earlier if we bound earlier), but it will not be efficient. It will convert our `CircuitStateFn`s to `VectorStateFn`s through simulation internally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:56.841535Z",
     "start_time": "2020-05-14T11:51:56.316981Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.65443578+0.j -0.65411671+0.j -0.65077588+0.j -0.64558521+0.j\n",
      " -0.65582129+0.j -0.70897185+0.j -0.81391221+0.j -0.93426771+0.j]\n"
     ]
    }
   ],
   "source": [
    "evo_time_points = list(range(8))\n",
    "h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time: evo_time_points})\n",
    "\n",
    "print(np.array(h2_trotter_expectations.eval()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Executing `CircuitStateFn`s with the `CircuitSampler`\n",
    "\n",
    "The `CircuitSampler` traverses an Operator and converts any `CircuitStateFns` into approximations of the state function by a `DictStateFn` or `VectorStateFn` using a quantum backend. Note that in order to approximate the value of the `CircuitStateFn`, it must 1) send state function through a depolarizing channel, which will destroy all phase information and 2) replace the sampled frequencies with **square roots** of the frequency, rather than the raw probability of sampling (which would be the equivalent of sampling the **square** of the state function, per the Born rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:57.140528Z",
     "start_time": "2020-05-14T11:51:56.843614Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampled Trotterized energies:\n",
      " [-0.65852795 -0.67957719 -0.62398484 -0.63596607 -0.65287664 -0.67604568\n",
      " -0.80574308 -0.9564996 ]\n"
     ]
    }
   ],
   "source": [
    "sampler = CircuitSampler(backend=BasicAer.get_backend('qasm_simulator'))\n",
    "# sampler.quantum_instance.run_config.shots = 1000\n",
    "sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)\n",
    "sampled_trotter_energies = sampled_trotter_exp_op.eval()\n",
    "print('Sampled Trotterized energies:\\n {}'.format(np.real(sampled_trotter_energies)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note again that the circuits are replaced by dicts with ***squareroots*** of the circuit sampling probabilities. Take a look at one sub-expression before and after the conversion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-14T11:51:57.203960Z",
     "start_time": "2020-05-14T11:51:57.143170Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.18093119 * ZZ,\n",
      "-1.0523732 * II])),\n",
      "CircuitStateFn(\n",
      "               ┌───┐┌───┐┌───────┐┌───┐┌───┐┌───┐┌───────┐┌───┐┌───────┐»\n",
      "q_0: ───────■──┤ H ├┤ X ├┤ RZ(0) ├┤ X ├┤ H ├┤ X ├┤ RZ(0) ├┤ X ├┤ RZ(0) ├»\n",
      "     ┌───┐┌─┴─┐├───┤└─┬─┘└───────┘└─┬─┘├───┤└─┬─┘└───────┘└─┬─┘├───────┤»\n",
      "q_1: ┤ H ├┤ X ├┤ H ├──■─────────────■──┤ H ├──■─────────────■──┤ RZ(0) ├»\n",
      "     └───┘└───┘└───┘                   └───┘                   └───────┘»\n",
      "«     ┌───────┐┌───┐┌───────┐┌───┐┌───┐┌───┐┌───────┐┌───┐┌───┐┌───┐\n",
      "«q_0: ┤ RZ(0) ├┤ X ├┤ RZ(0) ├┤ X ├┤ H ├┤ X ├┤ RZ(0) ├┤ X ├┤ H ├┤ H ├\n",
      "«     ├───────┤└─┬─┘└───────┘└─┬─┘├───┤└─┬─┘└───────┘└─┬─┘├───┤├───┤\n",
      "«q_1: ┤ RZ(0) ├──■─────────────■──┤ H ├──■─────────────■──┤ H ├┤ H ├\n",
      "«     └───────┘                   └───┘                   └───┘└───┘\n",
      ")])\n",
      "\n",
      "After:\n",
      "\n",
      "ComposedOp(\n",
      "[OperatorMeasurement(AbelianSummedOp(\n",
      "[0.18093119 * ZZ,\n",
      "-1.0523732 * II])),\n",
      "DictStateFn({'01': 0.7071067811865476, '00': 0.7071067811865476})])\n"
     ]
    }
   ],
   "source": [
    "# print('Before:\\n')\n",
    "print(h2_trotter_expectations.reduce()[0][0])\n",
    "print('\\nAfter:\\n')\n",
    "print(sampled_trotter_exp_op[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "The Operator flow grants you a flexible and fun set of building blocks to use for algorithm construction and prototyping. Take a look at the [Operator flow API reference](https://qiskit.org/documentation/apidoc/qiskit.aqua.operators.html#module-qiskit.aqua.operators) for more detailed information about methods and interfaces."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "code",
   "language": "python",
   "name": "code"
  },
  "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "315.797px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}