Grover op.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from qiskit import Aer\n",
    "from qiskit.circuit import QuantumCircuit\n",
    "from qiskit.quantum_info import Operator, Statevector\n",
    "from qiskit.aqua.algorithms import IterativeAmplitudeEstimation as IQAE\n",
    "from qiskit.aqua.algorithms import AmplitudeEstimation as QAE\n",
    "\n",
    "from qiskit.aqua.components.uncertainty_problems.grover_operator import GroverOperator\n",
    "from qiskit.aqua.components.uncertainty_problems.bit_oracle import BitOracle\n",
    "from qiskit.aqua.utils import CircuitFactory\n",
    "from qiskit.circuit.library import LinearPauliRotations\n",
    "from qiskit.aqua.components.uncertainty_models import NormalDistribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a bit-oracle \n",
    "\n",
    "This oracle is used to mark objective qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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",
       "state_0: ┤ X ├───────■──┤ X ├─────\n",
       "         └───┘       │  └───┘     \n",
       "state_1: ────────────┼────────────\n",
       "         ┌───┐┌───┐┌─┴─┐┌───┐┌───┐\n",
       "state_2: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├\n",
       "         └───┘└───┘└───┘└───┘└───┘</pre>"
      ],
      "text/plain": [
       "         ┌───┐          ┌───┐     \n",
       "state_0: ┤ X ├───────■──┤ X ├─────\n",
       "         └───┘       │  └───┘     \n",
       "state_1: ────────────┼────────────\n",
       "         ┌───┐┌───┐┌─┴─┐┌───┐┌───┐\n",
       "state_2: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├\n",
       "         └───┘└───┘└───┘└───┘└───┘"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_f = BitOracle(3, [0, 2])  # 3 qubits, with objectives 0 and 2\n",
    "s_f.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grover operator\n",
    "\n",
    "Constructs the Grover operator based on the oracle $\\mathcal{S}_f$:\n",
    "$$\n",
    "\\mathcal{Q} = \\mathcal{A}\\mathcal{S}_0\\mathcal{A}^\\dagger\\mathcal{S}_f\n",
    "$$\n",
    "where $\\mathcal{A}$ defaults to $H^{\\otimes n}$, $\\mathcal{S}_0 = \\mathbb{I} - 2 |0\\rangle\\langle 0|$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = GroverOperator(s_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "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",
       "state_0: ┤ X ├───────■──┤ X ├┤ H ├┤ X ├────────────■──┤ X ├┤ X ├┤ H ├─────\n",
       "         ├───┤┌───┐  │  └───┘└───┘└───┘            │  ├───┤├───┤├───┤     \n",
       "state_1: ┤ H ├┤ X ├──┼─────────────────────────────■──┤ X ├┤ X ├┤ H ├─────\n",
       "         ├───┤├───┤┌─┴─┐┌───┐┌───┐┌───┐┌───┐┌───┐┌─┴─┐├───┤├───┤├───┤┌───┐\n",
       "state_2: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ X ├┤ H ├\n",
       "         └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘</pre>"
      ],
      "text/plain": [
       "         ┌───┐          ┌───┐┌───┐┌───┐               ┌───┐┌───┐┌───┐     \n",
       "state_0: ┤ X ├───────■──┤ X ├┤ H ├┤ X ├────────────■──┤ X ├┤ X ├┤ H ├─────\n",
       "         ├───┤┌───┐  │  └───┘└───┘└───┘            │  ├───┤├───┤├───┤     \n",
       "state_1: ┤ H ├┤ X ├──┼─────────────────────────────■──┤ X ├┤ X ├┤ H ├─────\n",
       "         ├───┤├───┤┌─┴─┐┌───┐┌───┐┌───┐┌───┐┌───┐┌─┴─┐├───┤├───┤├───┤┌───┐\n",
       "state_2: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ X ├┤ H ├\n",
       "         └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "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",
       "state_0: ┤ U3(pi,0,pi) ├──────────────■──┤ U3(pi,0,pi) ├────────────────░─»\n",
       "         └─────────────┘              │  └─────────────┘                ░ »\n",
       "state_1: ─────────────────────────────┼─────────────────────────────────░─»\n",
       "         ┌─────────────┐┌──────────┐┌─┴─┐  ┌──────────┐ ┌─────────────┐ ░ »\n",
       "state_2: ┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ X ├──┤ U2(0,pi) ├─┤ U3(pi,0,pi) ├─░─»\n",
       "         └─────────────┘└──────────┘└───┘  └──────────┘ └─────────────┘ ░ »\n",
       "«         ┌──────────┐ ░ ┌─────────────┐                                       »\n",
       "«state_0: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├───────────────────────────────■───────»\n",
       "«         ├──────────┤ ░ ├─────────────┤                               │       »\n",
       "«state_1: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├───────────────────■───────────┼───────»\n",
       "«         ├──────────┤ ░ ├─────────────┤┌──────────┐┌───┐┌─┴─┐┌─────┐┌─┴─┐┌───┐»\n",
       "«state_2: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ H ├┤ X ├┤ TDG ├┤ X ├┤ T ├»\n",
       "«         └──────────┘ ░ └─────────────┘└──────────┘└───┘└───┘└─────┘└───┘└───┘»\n",
       "«                                ┌───┐             ┌─────────────┐»\n",
       "«state_0: ──────────────■────■───┤ T ├──────■──────┤ U3(pi,0,pi) ├»\n",
       "«               ┌───┐   │  ┌─┴─┐┌┴───┴┐   ┌─┴─┐    ├─────────────┤»\n",
       "«state_1: ──■───┤ T ├───┼──┤ X ├┤ TDG ├───┤ X ├────┤ U3(pi,0,pi) ├»\n",
       "«         ┌─┴─┐┌┴───┴┐┌─┴─┐├───┤└┬───┬┘┌──┴───┴───┐├─────────────┤»\n",
       "«state_2: ┤ X ├┤ TDG ├┤ X ├┤ T ├─┤ H ├─┤ U2(0,pi) ├┤ U3(pi,0,pi) ├»\n",
       "«         └───┘└─────┘└───┘└───┘ └───┘ └──────────┘└─────────────┘»\n",
       "«         ┌─────────────┐ ░ ┌──────────┐\n",
       "«state_0: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         ├─────────────┤ ░ ├──────────┤\n",
       "«state_1: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         ├─────────────┤ ░ ├──────────┤\n",
       "«state_2: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         └─────────────┘ ░ └──────────┘</pre>"
      ],
      "text/plain": [
       "         ┌─────────────┐                 ┌─────────────┐                ░ »\n",
       "state_0: ┤ U3(pi,0,pi) ├──────────────■──┤ U3(pi,0,pi) ├────────────────░─»\n",
       "         └─────────────┘              │  └─────────────┘                ░ »\n",
       "state_1: ─────────────────────────────┼─────────────────────────────────░─»\n",
       "         ┌─────────────┐┌──────────┐┌─┴─┐  ┌──────────┐ ┌─────────────┐ ░ »\n",
       "state_2: ┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ X ├──┤ U2(0,pi) ├─┤ U3(pi,0,pi) ├─░─»\n",
       "         └─────────────┘└──────────┘└───┘  └──────────┘ └─────────────┘ ░ »\n",
       "«         ┌──────────┐ ░ ┌─────────────┐                                       »\n",
       "«state_0: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├───────────────────────────────■───────»\n",
       "«         ├──────────┤ ░ ├─────────────┤                               │       »\n",
       "«state_1: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├───────────────────■───────────┼───────»\n",
       "«         ├──────────┤ ░ ├─────────────┤┌──────────┐┌───┐┌─┴─┐┌─────┐┌─┴─┐┌───┐»\n",
       "«state_2: ┤ U2(0,pi) ├─░─┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ H ├┤ X ├┤ TDG ├┤ X ├┤ T ├»\n",
       "«         └──────────┘ ░ └─────────────┘└──────────┘└───┘└───┘└─────┘└───┘└───┘»\n",
       "«                                ┌───┐             ┌─────────────┐»\n",
       "«state_0: ──────────────■────■───┤ T ├──────■──────┤ U3(pi,0,pi) ├»\n",
       "«               ┌───┐   │  ┌─┴─┐┌┴───┴┐   ┌─┴─┐    ├─────────────┤»\n",
       "«state_1: ──■───┤ T ├───┼──┤ X ├┤ TDG ├───┤ X ├────┤ U3(pi,0,pi) ├»\n",
       "«         ┌─┴─┐┌┴───┴┐┌─┴─┐├───┤└┬───┬┘┌──┴───┴───┐├─────────────┤»\n",
       "«state_2: ┤ X ├┤ TDG ├┤ X ├┤ T ├─┤ H ├─┤ U2(0,pi) ├┤ U3(pi,0,pi) ├»\n",
       "«         └───┘└─────┘└───┘└───┘ └───┘ └──────────┘└─────────────┘»\n",
       "«         ┌─────────────┐ ░ ┌──────────┐\n",
       "«state_0: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         ├─────────────┤ ░ ├──────────┤\n",
       "«state_1: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         ├─────────────┤ ░ ├──────────┤\n",
       "«state_2: ┤ U3(pi,0,pi) ├─░─┤ U2(0,pi) ├\n",
       "«         └─────────────┘ ░ └──────────┘"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GroverOperator(s_f, insert_barriers=True).decompose().draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bernoulli example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x12ea31850>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 0.2\n",
    "angle = np.arcsin(np.sqrt(p))\n",
    "\n",
    "a_operator = QuantumCircuit(1)\n",
    "a_operator.ry(2 * angle, 0)\n",
    "a_operator.value_to_estimation = lambda x: x  # TODO remove that this is necessary\n",
    "\n",
    "q_operator = QuantumCircuit(1)\n",
    "q_operator.ry(4 * angle, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore', category=DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5 0.20000000018626451\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('statevector_simulator')\n",
    "ae = QAE(2, state_in=a_operator, grover_operator=q_operator)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "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",
       "eval_0: ───┤ U2(0,pi) ├──────────■──────────────────────────────■──────┤ H ├\n",
       "           ├──────────┤          │                        ┌───┐ │-pi/2 └───┘\n",
       "eval_1: ───┤ U2(0,pi) ├──────────┼───────────────■────────┤ H ├─■───────────\n",
       "        ┌──┴──────────┴──┐┌──────┴───────┐┌──────┴───────┐└───┘             \n",
       "   q_0: ┤ R(0.9273,pi/2) ├┤ circuit54**1 ├┤ circuit54**2 ├──────────────────\n",
       "        └────────────────┘└──────────────┘└──────────────┘                  </pre>"
      ],
      "text/plain": [
       "           ┌──────────┐                                                ┌───┐\n",
       "eval_0: ───┤ U2(0,pi) ├──────────■──────────────────────────────■──────┤ H ├\n",
       "           ├──────────┤          │                        ┌───┐ │-pi/2 └───┘\n",
       "eval_1: ───┤ U2(0,pi) ├──────────┼───────────────■────────┤ H ├─■───────────\n",
       "        ┌──┴──────────┴──┐┌──────┴───────┐┌──────┴───────┐└───┘             \n",
       "   q_0: ┤ R(0.9273,pi/2) ├┤ circuit54**1 ├┤ circuit54**2 ├──────────────────\n",
       "        └────────────────┘└──────────────┘└──────────────┘                  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ae.construct_circuit().decompose().draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the default $\\mathcal{Q}$ operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         ┌───┐┌───┐┌───┐┌─────────────┐┌───┐┌───┐┌───┐┌───┐┌────────────┐\n",
      "state_0: ┤ X ├┤ Z ├┤ X ├┤ RY(-0.9273) ├┤ X ├┤ Z ├┤ X ├┤ X ├┤ RY(0.9273) ├\n",
      "         └───┘└───┘└───┘└─────────────┘└───┘└───┘└───┘└───┘└────────────┘\n"
     ]
    }
   ],
   "source": [
    "flag_last_qubit = BitOracle(1, [0])  # 0th qubit is objective qubit\n",
    "q_default = GroverOperator(flag_last_qubit, a_operator)\n",
    "print(q_default.draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 0.019677546808452455\n"
     ]
    }
   ],
   "source": [
    "ae = QAE(2, a_operator, q_default)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Idle qubits \n",
    "\n",
    "Idle qubits are ignored in the creation $\\mathcal{S}_0$ reflection in the Grover operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   \n",
      "q_0: ──────■───────\n",
      "     ┌─────┴──────┐\n",
      "q_1: ┤ RY(0.9273) ├\n",
      "     └────────────┘\n"
     ]
    }
   ],
   "source": [
    "p = 0.2\n",
    "angle = np.arcsin(np.sqrt(p))\n",
    "\n",
    "a_with_idle = QuantumCircuit(2)\n",
    "a_with_idle.cry(2 * angle, 0, 1)\n",
    "a_with_idle.value_to_estimation = lambda x: x\n",
    "\n",
    "print(a_with_idle.draw())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that qubit 0 is not included in the $\\mathcal{S}_0$ reflection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                              »\n",
      "state_0: ─────────────────────────────────────────────────────────────────────»\n",
      "         ┌─────────────┐┌──────────┐┌─────────────┐┌──────────┐┌─────────────┐»\n",
      "state_1: ┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ U3(pi,0,pi) ├»\n",
      "         └─────────────┘└──────────┘└─────────────┘└──────────┘└─────────────┘»\n",
      "«                                                                         »\n",
      "«state_0: ──────────────────────■───────────────────────■─────────────────»\n",
      "«         ┌──────────────────┐┌─┴─┐┌─────────────────┐┌─┴─┐┌─────────────┐»\n",
      "«state_1: ┤ U3(-0.46365,0,0) ├┤ X ├┤ U3(0.46365,0,0) ├┤ X ├┤ U3(pi,0,pi) ├»\n",
      "«         └──────────────────┘└───┘└─────────────────┘└───┘└─────────────┘»\n",
      "«                                                                              »\n",
      "«state_0: ─────────────────────────────────────────────────────────────────────»\n",
      "«         ┌──────────┐┌─────────────┐┌──────────┐┌─────────────┐┌─────────────┐»\n",
      "«state_1: ┤ U2(0,pi) ├┤ U3(pi,0,pi) ├┤ U2(0,pi) ├┤ U3(pi,0,pi) ├┤ U3(pi,0,pi) ├»\n",
      "«         └──────────┘└─────────────┘└──────────┘└─────────────┘└─────────────┘»\n",
      "«                                                          \n",
      "«state_0: ─────────────────────■────────────────────────■──\n",
      "«         ┌─────────────────┐┌─┴─┐┌──────────────────┐┌─┴─┐\n",
      "«state_1: ┤ U3(0.46365,0,0) ├┤ X ├┤ U3(-0.46365,0,0) ├┤ X ├\n",
      "«         └─────────────────┘└───┘└──────────────────┘└───┘\n"
     ]
    }
   ],
   "source": [
    "s_f = BitOracle(2, [1])  # ignore first qubit\n",
    "q_with_idle = GroverOperator(s_f, a_with_idle, idle_qubits=[0])\n",
    "print(q_with_idle.decompose().draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initial_state = QuantumCircuit(2)\n",
    "# initial_state.x(0)\n",
    "# ae = QAE(2, a_factory=a_with_idle, q_factory=q_with_idle, initial_state=initial_state)\n",
    "# print(ae.construct_circuit().draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# result = ae.run(backend)\n",
    "# print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's turn the `X` gate off and then the rotation in the $\\mathcal{A}$ operator does not act."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initial_state = QuantumCircuit(2)\n",
    "# ae = QAE(2, a_factory=a_with_idle, q_factory=q_with_idle, initial_state=initial_state)\n",
    "# result = ae.run(backend)\n",
    "# print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expectation value of a quadratic function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContinuousQuadratic(QuantumCircuit):\n",
    "    def __init__(self, x_dist, y, rescaling_factor=0.1, name='A'):\n",
    "        num_qubits = x_dist.num_target_qubits + 1\n",
    "        super().__init__(num_qubits, name=name)\n",
    "        self.c = rescaling_factor\n",
    "        self.x_dist = x_dist\n",
    "        self.y = y\n",
    "        self.ub = x_dist.high\n",
    "                \n",
    "        indices = list(range(num_qubits - 1))\n",
    "        self.i_x = indices[:self.x_dist.num_target_qubits]\n",
    "        self.i_f = num_qubits - 1\n",
    "        \n",
    "        self._build()\n",
    "        \n",
    "    def _build(self):\n",
    "        q = self.qubits\n",
    "        beta_x = self.c / (self.x_dist.num_values - 1)\n",
    "        gamma_y = -self.c * self.y / self.ub\n",
    "\n",
    "        lin_x = LinearPauliRotations(self.x_dist.num_target_qubits, offset=2 * gamma_y, slope=2 * beta_x)\n",
    "\n",
    "        q_x = [q[i] for i in self.i_x]\n",
    "        q_f = q[self.i_f]\n",
    "        self.x_dist.build(self, q_x)\n",
    "        \n",
    "        self.compose(lin_x, qubits=q_x[:] + [q_f], inplace=True)\n",
    "        \n",
    "    def value_to_estimation(self, value):\n",
    "        return value * (self.ub / self.c) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = NormalDistribution(2, mu=1, sigma=1, low=0, high=2)\n",
    "a_X = ContinuousQuadratic(X, y=1)\n",
    "bad_state_reflection = BitOracle(a_X.num_qubits, [a_X.i_f])\n",
    "q_X = GroverOperator(bad_state_reflection, a_X, insert_barriers=False, mcx='v-chain')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "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",
       "  state_0: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_1: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_2: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_3: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_4: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤┌───┐┌─┴──┐├───┤┌───┐\n",
       "  state_5: ┤ X ├┤ H ├┤0   ├┤ H ├┤ X ├\n",
       "           └───┘└───┘│    │└───┘└───┘\n",
       "ancilla_0: ──────────┤1   ├──────────\n",
       "                     │  X │          \n",
       "ancilla_1: ──────────┤2   ├──────────\n",
       "                     │    │          \n",
       "ancilla_2: ──────────┤3   ├──────────\n",
       "                     └────┘          </pre>"
      ],
      "text/plain": [
       "           ┌───┐           ┌───┐     \n",
       "  state_0: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_1: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_2: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_3: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤       │   ├───┤     \n",
       "  state_4: ┤ X ├───────■───┤ X ├─────\n",
       "           ├───┤┌───┐┌─┴──┐├───┤┌───┐\n",
       "  state_5: ┤ X ├┤ H ├┤0   ├┤ H ├┤ X ├\n",
       "           └───┘└───┘│    │└───┘└───┘\n",
       "ancilla_0: ──────────┤1   ├──────────\n",
       "                     │  X │          \n",
       "ancilla_1: ──────────┤2   ├──────────\n",
       "                     │    │          \n",
       "ancilla_2: ──────────┤3   ├──────────\n",
       "                     └────┘          "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BitOracle(6, [0, 1, 2, 3, 4, 5], mcx='v-chain').draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running canonical QAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def post(x):\n",
    "    return a_X.value_to_estimation(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 8.651370895929562\n"
     ]
    }
   ],
   "source": [
    "ae = QAE(3, state_in=a_X, grover_operator=q_X, objective_qubits=[a_X.i_f], post_processing=post)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             ┌───┐                                                   »\n",
      "eval_0: ─────┤ H ├───────────────────────────────────────────────────»\n",
      "             ├───┤                                                   »\n",
      "eval_1: ─────┤ H ├───────────────────────────────────────────────────»\n",
      "             ├───┤                                                   »\n",
      "eval_2: ─────┤ H ├───────────────────────────────────────────────────»\n",
      "        ┌────┴───┴─────┐┌───┐┌─────────────────┐┌───┐                »\n",
      "   q_0: ┤ U3(pi/2,0,0) ├┤ X ├┤ U3(0.22042,0,0) ├┤ X ├───────■────────»\n",
      "        ├──────────────┤└─┬─┘└─────────────────┘└─┬─┘       │        »\n",
      "   q_1: ┤ U3(pi/2,0,0) ├──■───────────────────────■─────────┼────────»\n",
      "        └─┬──────────┬─┘                             ┌──────┴───────┐»\n",
      "   q_2: ──┤ RY(-0.1) ├───────────────────────────────┤ RY(0.066667) ├»\n",
      "          └──────────┘                               └──────────────┘»\n",
      "«                       ┌─────────┐                      ┌──────┐\n",
      "«eval_0: ───────────────┤0        ├──────────────────────┤0     ├\n",
      "«                       │         │┌─────────┐           │      │\n",
      "«eval_1: ───────────────┤         ├┤0        ├───────────┤1 qft ├\n",
      "«                       │         ││         │┌─────────┐│      │\n",
      "«eval_2: ───────────────┤         ├┤         ├┤0        ├┤2     ├\n",
      "«                       │  c_Q**1 ││         ││         │└──────┘\n",
      "«   q_0: ───────────────┤1        ├┤1 c_Q**2 ├┤1        ├────────\n",
      "«                       │         ││         ││  c_Q**4 │        \n",
      "«   q_1: ───────■───────┤2        ├┤2        ├┤2        ├────────\n",
      "«        ┌──────┴──────┐│         ││         ││         │        \n",
      "«   q_2: ┤ RY(0.13333) ├┤3        ├┤3        ├┤3        ├────────\n",
      "«        └─────────────┘└─────────┘└─────────┘└─────────┘        \n"
     ]
    }
   ],
   "source": [
    "print(ae.construct_circuit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# post(result['mle'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterative QAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4580526785717565\n"
     ]
    }
   ],
   "source": [
    "ae = IQAE(0.01, 0.01, state_in=a_X, grover_operator=q_X, objective_qubits=[a_X.i_f], post_processing=post)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quadratic expecation value with qubit-encoded offset parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DiscreteQuadratic(QuantumCircuit):\n",
    "    def __init__(self, x_dist, k, y_max, rescaling_factor=0.1, name='A'):\n",
    "        num_qubits = x_dist.num_target_qubits + k + 1\n",
    "        super().__init__(num_qubits, name=name)\n",
    "        self.c = rescaling_factor\n",
    "        self.x_dist = x_dist\n",
    "        self.k = k\n",
    "        self.y_max = y_max\n",
    "                \n",
    "        indices = list(range(num_qubits - 1))\n",
    "        self.i_x = indices[:self.x_dist.num_target_qubits]\n",
    "        self.i_y = indices[self.x_dist.num_target_qubits:]\n",
    "        self.i_f = num_qubits - 1\n",
    "        \n",
    "        self._build()\n",
    "        \n",
    "    def _build(self):\n",
    "        beta_x = self.c / (self.x_dist.num_values - 1) * self.x_dist.high\n",
    "        beta_y = -self.c / (2**self.k - 1) * self.y_max\n",
    "        \n",
    "        lin_x = LinearPauliRotations(self.x_dist.num_target_qubits, offset=0, slope=2 * beta_x)\n",
    "        lin_y = LinearPauliRotations(self.k, offset=0, slope=2 * beta_y)\n",
    "\n",
    "        q = self.qubits\n",
    "        q_x = [q[i] for i in self.i_x]\n",
    "        q_y = [q[i] for i in self.i_y]\n",
    "        q_f = q[self.i_f]\n",
    "        self.x_dist.build(self, q_x)\n",
    "        \n",
    "        self.compose(lin_x, qubits=q_x[:] + [q_f], inplace=True)\n",
    "        self.compose(lin_y, qubits=q_y[:] + [q_f], inplace=True)   \n",
    "        \n",
    "    def value_to_estimation(self, value):\n",
    "        return value / self.c ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() got an unexpected keyword argument 'initial_state'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-55fde4ccc6f3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mq_XY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGroverOperator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms_f\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma_XY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midle_qubits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mae\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mQAE\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma_factory\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ma_XY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_factory\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mq_XY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minit_y\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'initial_state'"
     ]
    }
   ],
   "source": [
    "a_XY = DiscreteQuadratic(X, k=2, y_max=3)\n",
    "init_y = QuantumCircuit(5)\n",
    "init_y.x(2)\n",
    "# X.build(init_y, init_y.qubits[:2])\n",
    "s_f = BitOracle(5, [4])  # ignore first qubit\n",
    "q_XY = GroverOperator(s_f, a_XY, idle_qubits=[2, 3])\n",
    "\n",
    "ae = QAE(3, a_factory=a_XY, q_factory=q_XY, initial_state=init_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "result = ae.run(backend)\n",
    "print(result['estimation'], result['mle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ae = IQAE(0.01, 0.01, a_factory=a_XY, q_factory=q_XY, initial_state=init_y, i_objective=4)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bernoulli with ancillas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit import AncillaRegister, QuantumRegister\n",
    "\n",
    "p = 0.2\n",
    "angle = np.arcsin(np.sqrt(p))\n",
    "\n",
    "qr, ar = QuantumRegister(1), AncillaRegister(1)\n",
    "\n",
    "a_operator = QuantumCircuit(qr)#, ar)\n",
    "a_operator.ry(2 * angle, qr[0])\n",
    "a_operator.value_to_estimation = lambda x: x  # TODO remove that this is necessary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_operator.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_operator.num_ancillas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_state_qubits = a_operator.num_qubits - a_operator.num_ancillas\n",
    "flag_last_qubit = BitOracle(num_state_qubits, [num_state_qubits - 1])  # 0th qubit is objective qubit\n",
    "q_default = GroverOperator(flag_last_qubit, a_operator)\n",
    "print(q_default.draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('qasm_simulator')\n",
    "ae = IQAE(0.01, 0.01, a_factory=a_operator, q_factory=q_default)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'])#, result['mle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ae.construct_circuit(2).draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ae.construct_circuit().decompose().draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BernoulliAFactory(CircuitFactory):\n",
    "    r\"\"\"Circuit Factory representing the operator A in a Bernoulli problem.\n",
    "\n",
    "    Given a probability $p$, the operator A prepares the state $\\sqrt{1 - p}|0> + \\sqrt{p}|1>$.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, probability=0.5):\n",
    "        #\n",
    "        super().__init__(1)\n",
    "        self._probability = probability\n",
    "        self.i_state = 0\n",
    "        self._theta_p = 2 * np.arcsin(np.sqrt(probability))\n",
    "\n",
    "    def build(self, qc, q, q_ancillas=None, params=None):\n",
    "        # A is a rotation of angle theta_p around the Y-axis\n",
    "        qc.ry(self._theta_p, q[self.i_state])\n",
    "\n",
    "    def value_to_estimation(self, value):\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_factory = BernoulliAFactory(0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('qasm_simulator')\n",
    "ae = IQAE(0.01, 0.01, a_factory=a_factory)\n",
    "result = ae.run(backend)\n",
    "print(result['estimation'])#, result['mle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ae.construct_circuit().decompose().draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.aqua.algorithms import VQE\n",
    "from qiskit.aqua.operators import *\n",
    "from qiskit.circuit import ParameterVector\n",
    "from qiskit.circuit.library import RealAmplitudes\n",
    "\n",
    "op = (X ^ X) + (Z ^ Z) + (Y ^ Y)\n",
    "ansatz = RealAmplitudes(2)\n",
    "vqe = VQE(op, ansatz, expectation=MatrixExpectation())\n",
    "exp = vqe.construct_circuit(ParameterVector('p', ansatz.num_parameters))\n",
    "print(exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp.oplist[0].to_circuit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.5 64-bit ('latest': virtualenv)",
   "language": "python",
   "name": "python37564bitlatestvirtualenv76cfe9d7d3f749489cf2ff69593234af"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}