Quantum State Preparation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f7c7a175-6201-40ad-b948-1bf29c09d53a",
   "metadata": {},
   "source": [
    "# Quantum State Preparation\n",
    "\n",
    "Implementation of the paper [Black-Box Quantum State Preparation without Arithmetic](https://doi.org/10.1103/PhysRevLett.122.020502)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2848b51d-1765-4172-9e99-7ac9265af515",
   "metadata": {},
   "source": [
    "### Problem statement\n",
    "\n",
    "Given an array of $m$ decimal values \n",
    "$$A = (a_0, ..., a_{m-1})$$\n",
    "such that $a_i \\in [0, 1)$, prepare the quantum state \n",
    "$$|\\psi\\rangle = \\frac{1}{||A||}\\sum_{i=0}^{m-1}a_i|i\\rangle$$\n",
    "where $||A||$ is the normalization constant, and is equal to the magnitude of the vector represented by $A$. $$||A|| = \\sqrt{\\sum_{i=0}^{m-1}{a_i}^2}$$\n",
    "\n",
    "We have access to a black-box $amp$ which has the following action - \n",
    "$$amp|i\\rangle|z\\rangle = |i\\rangle|z \\oplus a_{i}^{(n)}\\rangle $$\n",
    "\n",
    "where $a_{i}^{n}$ is the data $a_{i}$ upto $n$ bits of precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7a97d136-6a59-4448-aa36-65ce08431309",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import Aer, execute, QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.circuit.library.standard_gates import RYGate, MCXGate, ZGate\n",
    "from qiskit.circuit.controlledgate import ControlledGate\n",
    "from qiskit.algorithms import Grover, AmplificationProblem\n",
    "from qiskit.utils import QuantumInstance\n",
    "from qiskit.visualization import plot_histogram\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "549df852-a83f-4ccf-a20e-aa7212024958",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_aln(al, n):\n",
    "    \"\"\" Returns the binary form upto n bits of precision of the input decimal data. \"\"\"\n",
    "    aln = \"\"\n",
    "    for i in range(n):\n",
    "        al *= 2\n",
    "        aln += str(int(al))\n",
    "        al = al - int(al)\n",
    "        \n",
    "    # aln = \"0.\" + aln\n",
    "    return aln"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "069c430d-62d3-4d74-8d52-556211c7b16c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_get_aln(aln, al):\n",
    "    aln = aln[2:]\n",
    "    check_al = 0\n",
    "    p = 0.5\n",
    "    for dig in aln:\n",
    "        check_al += p*int(dig)\n",
    "        p /= 2\n",
    "    print(abs(al - check_al))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d7659bb5-20aa-47c9-ba51-8f48874348e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def aln_to_gate(aln, n):\n",
    "    \"\"\" Constructs the gate that corresponds to the input binary string - X for bit '1' and I for bit '0'. \"\"\"\n",
    "    qc = QuantumCircuit(n)\n",
    "    for i, dig in enumerate(aln):\n",
    "        if dig == '1':\n",
    "            qc.x(i)\n",
    "    return qc.to_gate(label=aln)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e3381505-094c-4613-80bf-c1953ca2fa28",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_sv(sv, modified):\n",
    "    vals = []\n",
    "    \n",
    "    if modified == False:\n",
    "        print(\"  Out   Data  Flag  Amplitude    Probability\")\n",
    "        for j in range(len(sv.data)):\n",
    "            if np.abs(sv.data[j]) > 0.00001:\n",
    "                vals.append((bin(j)[2:].rjust(d+n+1, '0')[::-1][0:d], bin(j)[2:].rjust(d+n+1, '0')[::-1][d:d+n], bin(j)[2:].rjust(d+n+1, '0')[::-1][d+n:], \"{:.8f}\".format(np.abs(sv.data[j])), \"{:.8f}\".format(np.abs(sv.data[j])**2)))        \n",
    "    else:\n",
    "        print(\"  Out   Data   Ref  Flag  Amplitude           Probability\")\n",
    "        for j in range(len(sv.data)):\n",
    "            if np.abs(sv.data[j]) > 0.00001:\n",
    "                vals.append((bin(j)[2:].rjust(d+2*n+1, '0')[::-1][0:d], bin(j)[2:].rjust(d+2*n+1, '0')[::-1][d:d+n], bin(j)[2:].rjust(d+2*n+1, '0')[::-1][d+n:d+2*n], bin(j)[2:].rjust(d+2*n+1, '0')[::-1][d+2*n:], \"{:.8f}\".format(np.abs(sv.data[j])), \"{:.8f}\".format(np.abs(sv.data[j])**2)))        \n",
    "    vals.sort(key = lambda x: x[0])\n",
    "    return vals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f57ee968-ca97-4a22-bcd8-9743f52f533f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Initializing the data\n",
    "\n",
    "We set $n$ (the precision) and $m$ (the number of data elements), and find $d$ (the number of bits required by the index register to represent $m$ values). \n",
    "\n",
    "Since the number of basis states is always a power of $2$, we set the remaining amplitudes as $0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a49d3c23-76d7-48ea-bb35-c43d981b4778",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "n = 3\n",
    "m = 2\n",
    "data_m = m\n",
    "d = int(np.ceil(np.log2(m)))\n",
    "\n",
    "if d - np.log2(m) != 0:\n",
    "    data_m = m\n",
    "    m = 2**d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "02aad7ee-fd3f-4fa2-96e3-3ee9fe179fae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2 1 2\n"
     ]
    }
   ],
   "source": [
    "print(n, m, d, data_m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9874009c-0f73-4865-80fc-04dc8089e4da",
   "metadata": {},
   "source": [
    "We take up a toy example, where\n",
    "$$ A = [0.375, 0.125] $$\n",
    "\n",
    "The precision ($n$) is set to $3$, hence the binary representation of the data will be calculated upto $3$ places."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf57dd00-aefa-4db1-b89f-69e10412746e",
   "metadata": {},
   "source": [
    "The code in this notebook will also work with a randomly generated array of any length and with any precision by - \n",
    "1. Updating `n` and `m` in the above cell\n",
    "2. Uncommenting the first two lines of the next cell\n",
    "3. Commenting out the third line of the next cell\n",
    "\n",
    "Alternatively, an array of values may be specified directly and initialzed as `A_vals`, provided `n` and `m` are set correctly in the previous cell, and `m` is a power of $2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d8fcea42-0881-4b92-82a5-7d2ec7511d64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data : [0.375, 0.125]\n",
      "Binary form upto 3 places : ['011', '001']\n",
      "Decimal data after rounding to 3 places : [0.375, 0.125]\n"
     ]
    }
   ],
   "source": [
    "# A_vals = [np.random.rand() for i in range(data_m)]\n",
    "# A_vals += [0 for i in range(m - data_m)]\n",
    "\n",
    "A_vals = [0.375, 0.125]\n",
    "print(f\"Data : {A_vals}\")\n",
    "A = [get_aln(A_vals[i], n) for i in range(m)]\n",
    "print(f\"Binary form upto {n} places : {A}\")\n",
    "dec = 2**n\n",
    "A_vals_n = [int(A[i], 2)/dec for i in range(m)]\n",
    "print(f\"Decimal data after rounding to {n} places : {A_vals_n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4087a154-4bfb-46d3-b5f2-0c38d457475b",
   "metadata": {},
   "source": [
    "# Grover's state preparation algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1204e11f-3caf-441e-a4fb-73f200cd6b37",
   "metadata": {},
   "source": [
    "#### Step 1 - Initialization\n",
    "The circuit is initialized with `out`, `data` and `flag`  registers, and with `out` register in equal superposition (to represent indices).\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_0\\rangle &= H^{\\otimes d}|0^{\\otimes d}\\rangle_{out} \\otimes |0^{\\otimes n}\\rangle_{data} \\otimes |0\\rangle_{flag} \\\\\n",
    "|\\psi_0\\rangle &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|0^{\\otimes n}\\rangle_{data}|0\\rangle_{flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $M = 2^d$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e6cc8e13-e637-49c8-9275-b0b3b2511b7c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def initializer(A, d, m, n, modified):\n",
    "    \"\"\" Initializes a circuit with the appropriate registers for Grover's state preparation method, or the modified version. \n",
    "        Also puts the first register in an equal superposition. \"\"\"\n",
    "    out = QuantumRegister(d, name = \"out\")\n",
    "    data = QuantumRegister(n, name = \"data\")\n",
    "    ref = QuantumRegister(n, name = \"ref\")\n",
    "    flag = QuantumRegister(1, name = \"flag\")\n",
    "    \n",
    "    if modified:\n",
    "        circ = QuantumCircuit(out, data, ref, flag, name = \"init\")\n",
    "    else:\n",
    "        circ = QuantumCircuit(out, data, flag, name = \"init\")\n",
    "        \n",
    "    k = int(np.log2(m))\n",
    "    for i in range(k):\n",
    "        circ.h([i for i in range(k)])\n",
    "        \n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4571697b-52c5-4dcc-a1ff-ef46fd18429f",
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_orig = initializer(A, d, m, n, False)\n",
    "sv_orig_0 = Statevector.from_instruction(qc_orig) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "53a4a3d8-e26c-4e5f-a186-48bba61c2f37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data  Flag  Amplitude    Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '000', '0', '0.70710678', '0.50000000'),\n",
       " ('1', '000', '0', '0.70710678', '0.50000000')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_orig_0, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf05109-4956-47b6-aa03-71ad362e7834",
   "metadata": {},
   "source": [
    "#### Step 2 - Apply black box `amp`\n",
    "\n",
    "Next, the oracle is applied on the circuit, which prepares the system in the state \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_1\\rangle &= (amp \\otimes I) |\\psi_0\\rangle \\\\\n",
    "|\\psi_1\\rangle &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}|0\\rangle_{flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "$amp$ has the following action - \n",
    "$$amp|i\\rangle|z\\rangle = |i\\rangle|z \\oplus a_{i}^{(n)}\\rangle $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7e7e0c3b-9077-4c27-b245-485c98c38aa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def oracle(A, d, m, n):\n",
    "    \"\"\" Loads the data array onto the circuit, controlled by register out as index. \"\"\"\n",
    "    circ = QuantumCircuit(d+n, name = \"oracle\")\n",
    "    for i in range(m):\n",
    "        aln_gate = aln_to_gate(A[i], n).control(num_ctrl_qubits = d, label = str(A[i]), ctrl_state = bin(i)[2:].rjust(d, \"0\")[::-1])\n",
    "        circ.append(aln_gate, [i for i in range(0, d+n)])\n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dbc4fecc-2726-4df0-9ee6-27e31f7f31b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "black_box = oracle(A, d, m, n)\n",
    "qc_orig.append(black_box, qargs = [i for i in range(0,d+n)])\n",
    "sv_orig_1 = Statevector.from_instruction(qc_orig) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "51a01781-0630-400b-92e6-eb3bcfd98ac0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data  Flag  Amplitude    Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '0', '0.70710678', '0.50000000'),\n",
       " ('1', '001', '0', '0.70710678', '0.50000000')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_orig_1, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b7d194c-a570-45db-a3c7-3a3fc8e9f630",
   "metadata": {},
   "source": [
    "#### Step 3 - Perform rotation operation\n",
    "\n",
    "The $rot$ operator is applied on the system, which results in the following state\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_2\\rangle &= rot|\\psi_1\\rangle \\\\\n",
    "|\\psi_2\\rangle &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}(\\sin{\\theta_i}|0\\rangle_{flag} + \\cos{\\theta_i}|1\\rangle_{flag})\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $\\theta_i = \\arcsin{\\frac{a_{i}^{(n)}}{2^n}}$\n",
    "\n",
    "In the case of the toy example, we have \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_2\\rangle &= \\frac{1}{2}|0\\rangle_{out}|011\\rangle_{data}(0.375|0\\rangle_{flag} + 0.927|1\\rangle_{flag}) \\\\\n",
    "               &+ \\frac{1}{2}|1\\rangle_{out}|001\\rangle_{data}(0.125|0\\rangle_{flag} + 0.992|1\\rangle_{flag}) \n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b2f01625-4ad6-4ae2-a30c-2b67a2192766",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate(A_vals_n, d, m):\n",
    "    \"\"\" Applies a CRY(θ_i) Gate with θ_i = ith data element (upto n bits), and controlled by out register as index. \"\"\"\n",
    "    circ = QuantumCircuit(d+1, name = \"rot\")\n",
    "    for i in range(m):\n",
    "        theta_i = np.pi - 2*np.arcsin(A_vals_n[i])\n",
    "        ry_gate = RYGate(theta = theta_i)\n",
    "        circ.append(ry_gate.control(num_ctrl_qubits = d, label = str(A[i]), ctrl_state = bin(i)[2:].rjust(d, \"0\")[::-1]), [j for j in range(d+1)]) \n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6ab067b0-471d-4cef-8a64-2a4e90422a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "rot = rotate(A_vals_n, d, m)\n",
    "qc_orig.append(rot, qargs = [i for i in range(0,d)] + [d+n])\n",
    "sv_orig_2 = Statevector.from_instruction(qc_orig)\n",
    "# qc_orig.measure_all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "728eb93c-7c38-41cf-8589-397151abf85e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data  Flag  Amplitude    Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '0', '0.26516504', '0.07031250'),\n",
       " ('0', '011', '1', '0.65550553', '0.42968750'),\n",
       " ('1', '001', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '1', '0.70156076', '0.49218750')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_orig_2, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "579e3124-b7eb-4696-8b3a-2d10c38cc05f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 361.147x325.08 with 1 Axes>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc_orig.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b076f88d-54c4-4774-b5ee-fd6024d42b99",
   "metadata": {},
   "source": [
    "#### Step 4 - Perform amplitude amplification\n",
    "\n",
    "The system now contains the target state, which has the data elements as amplitudes of the basis vectors. However the rotation also introduces some unwanted states (where ```flag``` register is $1$). To eliminate these states and increase the probability of the desired state, we perform amplitude amplification on the state $|\\psi_2\\rangle$. After amplitude amplification, we will be left with a superposition of the desired state, and an undesired state (with ```flag``` register as $1$), which has a small probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3a5d07ca-0bde-4079-9cd6-f3d34938f908",
   "metadata": {},
   "outputs": [],
   "source": [
    "def phase_oracle(d, n, modified):\n",
    "    \"\"\" Flips the phase of the state to be amplified. \"\"\"\n",
    "    out = QuantumRegister(d, name = \"out\")\n",
    "    data = QuantumRegister(n, name = \"data\")\n",
    "    ref = QuantumRegister(n, name = \"ref\")\n",
    "    flag = QuantumRegister(1, name = \"flag\")\n",
    "    \n",
    "    if modified:\n",
    "        # Good state has ref and flag registers as all 0s\n",
    "        circ = QuantumCircuit(out, data, ref, flag, name = \"Phase Oracle\")\n",
    "        circ.x(flag)\n",
    "        circ.append(ZGate().control(num_ctrl_qubits = n, label = \"phase\", ctrl_state = \"0\"*n), [i for i in range(d+n, d+(2*n)+1)])\n",
    "        circ.x(flag)\n",
    "    else:\n",
    "        # Good state has flag register as all 0s\n",
    "        circ = QuantumCircuit(out, data, flag, name = \"Phase Oracle\")\n",
    "        circ.x(flag)\n",
    "        circ.z(flag)\n",
    "        circ.x(flag)\n",
    "    \n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d1e81065-4d24-4924-8126-a776a7bf2e8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('aer_simulator')\n",
    "quantum_instance = QuantumInstance(backend)\n",
    "\n",
    "problem = AmplificationProblem(oracle = phase_oracle(d, n, False), state_preparation = qc_orig, objective_qubits = [i for i in range(0,d+n+1)], is_good_state = ['00110', '10010'])\n",
    "grover = Grover(quantum_instance=quantum_instance)\n",
    "\n",
    "out = QuantumRegister(d, name = \"out\")\n",
    "data = QuantumRegister(n, name = \"data\")\n",
    "flag = QuantumRegister(1, name = \"flag\")\n",
    "check = ClassicalRegister(d+1, name = \"check\")\n",
    "\n",
    "state_prep = QuantumCircuit(out, data, flag, check, name = \"State preparation\")\n",
    "\n",
    "# Construct the Grover circuit and apply the Grover operator twice to amplify the good states\n",
    "grover_ckt = grover.construct_circuit(problem, power = 2)\n",
    "state_prep.append(grover_ckt, [i for i in range(0, d+n+1)])\n",
    "sv_orig_3 = Statevector.from_instruction(state_prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "161af5fe-0536-46dd-aa04-0486a00a951e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data  Flag  Amplitude    Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '0', '0.93739986', '0.87871850'),\n",
       " ('0', '011', '1', '0.10498331', '0.01102149'),\n",
       " ('1', '001', '0', '0.31246662', '0.09763539'),\n",
       " ('1', '001', '1', '0.11235934', '0.01262462')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_orig_3, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "761dd74e-66c0-411e-ab87-8d45f2dc607f",
   "metadata": {},
   "source": [
    "#### Step 5 - Unprepare `data` register\n",
    "The `data` register is 'unprepared' by applying the oracle again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "150b87fa-fcfa-4672-85dc-c485e8ea47a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unload the data from data register by reapplying the oracle\n",
    "state_prep.append(black_box, qargs = [i for i in range(0,d+n)])\n",
    "sv_orig_4 = Statevector.from_instruction(state_prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "403980c4-79f5-44bf-aa26-d449bf0e4bd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data  Flag  Amplitude    Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '000', '0', '0.93739986', '0.87871850'),\n",
       " ('0', '000', '1', '0.10498331', '0.01102149'),\n",
       " ('1', '000', '0', '0.31246662', '0.09763539'),\n",
       " ('1', '000', '1', '0.11235934', '0.01262462')]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_orig_4, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4ecdcb4-5dab-43de-9ea2-07aaac19ae37",
   "metadata": {},
   "source": [
    "#### Step 6 - Measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c41a17d1-a0f9-49f6-b378-797e073614d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x1d7531b6e80>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Measure the flag register\n",
    "state_prep.measure([out[i] for i in range(d)] + [flag[0]], check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3b25bbcb-aaac-471c-91b5-f520a0d1f4f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 482.122x385.28 with 1 Axes>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_prep.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e9ecb5-8444-4ffd-a9f7-29ba881bb8a0",
   "metadata": {},
   "source": [
    "The algorithm is successful if the `flag` register results in $0$. In this case, the system collapses to the desired state. We observe that the states with value of `flag` as $0$ have high probability after amplitude amplification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0f075eb6-4ae1-4a6e-9aa9-8c8244f6f4d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'00': 857, '01': 117, '11': 16, '10': 10}\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('aer_simulator')\n",
    "\n",
    "res = execute(state_prep, backend, shots=1000).result()\n",
    "counts = res.get_counts()\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d1f39079-742e-46cf-adec-3f003fee0888",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAE6CAYAAAB00gm8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAng0lEQVR4nO3dfXxU9Zn38c8FkYiLWB4MEBKFGAiSaNI4GFMR7CrV1S1VuytSW2WxeOPjeqvbdu/W3drtVlutq1WRyro+tStqtWW7VXzmycZgSBcFFLIlKEQICiigGEy87j/OBIcwCWdkMjNkvu/XK6/MnPM7J9fhF/Kd33k0d0dERET2r1e6CxARETlYKDRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkpJx0F5BOgwcP9hEjRqS7DBERySDLli17z92PjDcvq0NzxIgR1NXVpbsMERHJIGb2VmfztHtWREQkpJSGpplNMLP/MrMmM3MzmxZimePMbKGZ7You909mZh3aTDSzZWb2sZmtNbOZ3bYRIiKStVI90uwHrAD+Hti1v8Zm1h94DmgGxgFXA/8AXBvTZiTwFPBH4IvATcCdZvb1ZBcvIiLZLaXHNN39KYKAw8weCLHIhcBhwMXuvgtYYWbHAtea2W0e3Dh3JvCOu18VXeYNM6sCrgeeSPY2iIhI9sr0Y5rVwOJoYLZ7BsgHRsS0ebbDcs8AETM7pNsrFBGRrJHpZ88OBTZ0mNYcM68x+v35OG1ygMHAxtgZZnYpcClAfn4+CxYsAKCoqIjDDz+c5cuXAzBo0CBKS0tZtGgRADk5OYwfP576+nq2b98OQCQSobm5mfXr1wMwatQocnNzWbFiBQB5eXmMHj2aJUuWAJCbm0t1dTV1dXXs3LkTgKqqKjZs2EBTUxMAJSUl9O7dm1WrVgUbOXQoI0eOpKamBoC+fftSVVVFbW0tu3YFnyWqq6tpbGxk06ZNAIwdO5a2tjZWr14NwPDhwykoKKC2thaAfv36EYlEqKmpoaWlBYDx48ezZs0aNm/eDEBZWRktLS00NDQAUFhYyJAhQ/acbdy/f38qKytZsmQJra2tAEyYMIGVK1eyZcsWAMrLy9mxYwdr164FgrOVBw4cSH19PQADBgygvLychQsX4u6YGRMnTmT58uVs27YNgMrKSrZu3cq6devUT+on9ZP6KSX91BVL16PBzGwncKW7P9BFm2eB9e5+Scy0o4F1QLW7v2Jma4CH3f1fYtpMBBYAw9x9U2frj0QirktOREQklpktc/dIvHmZvnt2E8FIMlZe9Hvzftq0Alu6rzQREck2mR6aNcApZnZozLRJwDsEo832Nqd3WG4SUOfun3R7hSIikjVSfZ1mPzOrMLOK6M8+Kvr+qOj8m8zshZhF/hP4CHjAzMrM7Dzge0D7mbMAs4ECM7vdzI41s28D04BbU7RZIiKSJVI90owAf4p+9QVujL7+UXT+MOCY9sbu/gHBqDEfqAPuBn4O3BbTphE4C5gA/A/wfeBqd9flJiIiklSpvk5zAWBdzJ8WZ9rrBIHY1XoXApUHWJ6IiEiXMv2YpoiISMZQaIqIiISk0BQREQlJoSkiIhKSQlNERCQkhaaIiEhICk0REZGQFJoiIiIhKTRFRERCUmiKiIiEpNBMk/nz51NSUkJxcTE333zzPvM/+OADvvrVr1JeXk5paSn333//nnkjRozguOOOo6Kigkjks0e+TZkyhYqKCioqKhgxYgQVFRWp2BQRkayR0nvPSqCtrY0rrriC5557joKCAsaNG8fkyZMZO3bsnjZ33303Y8eO5fe//z3vvvsuJSUlXHjhhfTp0weAl156icGDB++13kcffXTP6+uuu44jjjgiNRskIpIlNNJMg6VLl1JcXExRURF9+vThggsuYN68eXu1MTN27NiBu7Nz504GDhxITk64zzjuzmOPPcbUqVO7o3wRkayl0EyDpqYmCgsL97wvKCigqalprzZXXnklb7zxBvn5+Rx33HHccccd9OoVdJeZ8ZWvfIUTTjiBe++9d5/1L168mCFDhjBq1Kju3RARkSyj3bNp8Nnzsz9jtvcT05555hkqKip48cUX+fOf/8ykSZM45ZRT6N+/Py+//DL5+fls3ryZSZMmMWbMGCZM+OzpaY888ohGmSIi3UAjzTQoKChg/fr1e95v2LCB/Pz8vdrcf//9nHfeeZgZxcXFjBw5kjfffBNgT9u8vDzOPfdcli5dume51tZWnnzySaZMmZKCLRERyS4KzTQYN24cDQ0NNDY2snv3bubOncvkyZP3anPUUUfxwgsvANDc3Mzq1aspKiriww8/ZMeOHQB8+OGHPPvss5SVle1Z7vnnn2fMmDEUFBSkboNERLKEds+mQU5ODnfddRdnnHEGbW1tTJ8+ndLSUmbPng3AzJkzueGGG5g2bRrHHXcc7s5Pf/pTBg8ezNq1azn33HOBYFT5jW98gzPPPHPPuufOnatdsyIi3cTiHV/LFpFIxOvq6tJdhoiIZBAzW+bukXjztHtWREQkJIWmiIhISApNERGRkBSaIiIiISk0RUREQlJoioiIhKTQFBERCUmhKSIiEpJCU0REJCSFpoiISEgKTRERkZAUmiIiIiHpKSdJMOP2dFeQPHOuSXcFIiKZSyNNERGRkBSaIiIiISk0RUREQlJoioiIhKTQFBERCUmhKSIiEpJCU0REJCSFpoiISEgKTRERkZAUmiIiIiEpNEVEREJSaIqIiISk0BQREQlJoSkiIhKSQlNERCQkhaaIiEhICk0REZGQFJoiIiIhKTRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkpJSHppldbmaNZvaxmS0zs1O6aPtDM/NOvvKibU7tZP6Y1G2ViIhkg5xU/jAzmwLcAVwOLIl+f9rMxrr723EWuRWY3WHaXMDdfXOH6aXA1pj37yanahERkUCqR5rXAg+4+xx3f8PdrwI2ApfFa+zuO919U/sXcAhwCjAnTvPNsW3dva3btkJERLJSykLTzPoAJwDPdpj1LPClkKu5BHgfeCLOvDoz22hmL5jZlz93oSIiIp1I5e7ZwUBvoLnD9Gbg9P0tbGa9gOnAQ+7eEjOrfaT6KtAH+Bbwgpmd6u6L4qznUuBSgPz8fBYsWABAUVERhx9+OMuXLwdg0KBBlJaWsmhRsIqcnBzGjx9PfX0927dvByASidDc3AwcE+of4GDQ/u9RVlZGS0sLDQ0NABQWFjJkyBDq6uoA6N+/P5WVlSxZsoTW1lYAJkyYwMqVK9myZQsA5eXl7Nixg7Vr1wIwYsQIBg4cSH19PQADBgygvLychQsX4u6YGRMnTmT58uVs27YNgMrKSrZu3cq6deuAA+un9evXAzBq1Chyc3NZsWIFAHl5eYwePZolS5YAkJubS3V1NXV1dezcuROAqqoqNmzYQFNTEwAlJSX07t2bVatWATB06FBGjhxJTU0NAH379qWqqora2lp27doFQHV1NY2NjWzatAmAsWPH0tbWxurVqwEYPnw4BQUF1NbWAtCvXz8ikQg1NTW0tAS/8uPHj2fNmjVs3rxZ/aR+Uj91Uz91xdy9ywbJYmb5QBMwwd0Xx0z/Z2Cqu3d54o6Z/TXwe6DM3Vfup+1TQKu7T+6qXSQS8fZf2gMx4/YDXkXGmHNNuisQEUkvM1vm7pF481J5TPM9oA0Y2mF6HvuOPuOZAfxxf4EZVQuMSqw8ERGRrqUsNN19N7AMmNRh1iTgj10tGx2lnk38E4DiqSDYbSsiIpI0Kb3kBLgNeNjMlgIvAzOBfKKXlZjZTcCJ7n5ah+WmAx8Cj3VcoZldA6wDVhIc0/wmcA7w9e7YABERyV4pDU13f9TMBgE/AIYBK4Cz3P2taJNhdDirxsyM4KzZX7v7R3FW24fges7hwC6C8Dzb3Z/qnq0QEZFsleqRJu4+C5jVybxpcaY5MLKL9f0M+Fmy6hMREemM7j0rIiISkkJTREQkJIWmiIhISApNERGRkBSaIiIiISk0RUREQlJoioiIhKTQFBERCUmhKSIiEpJCU0REJCSFpoiISEgKTRERkZAUmiIiIiEpNEVEREJSaIqIiISk0BQREQkpodA0s15m1ivm/VAz+7aZnZz80kRERDJLoiPNPwBXAZhZP6AOuAVYYGYXJbk2ERGRjJJoaJ4AvBh9fR6wHcgDZgDXJ7EuERGRjJNoaB4OvB99/RXgt+7+CUGQHpPEukRERDJOoqH5NnCymf0FcAbwXHT6QOCjZBYmIiKSaXISbH8b8DCwE3gLWBSdPgF4PYl1iYiIZJyEQtPdf2lmy4BC4Dl3/zQ668/ADckuTkREJJMkOtLE3esIzpqNnfaHpFUkIiKSoRK+uYGZXW5mK83sIzMrik77rpmdn/zyREREMkeiNze4BvgBcC9gMbPeAa5MXlkiIiKZJ9GR5kxghrvfAbTGTK8HSpNWlYiISAZKNDSPBlbEmf4J0PfAyxEREclciYbmWqAyzvSzgFUHXo6IiEjmSvTs2VuBu8zsMIJjmtVm9i3gO8D0ZBcnIiKSSRK9TvN+M8sBfgIcRnCjgybgand/tBvqExERyRif5zrNOcAcMxsM9HL3zckvS0REJPMkHJrt3P29ZBYiIiKS6fYbmmb2GjDR3beZ2euAd9bW3Y9PZnEiIiKZJMxI8wmgJeZ1p6EpIiLSk+03NN39xpjXP+zWakRERDJYorfRe9HMvhBnen8zezFpVYmIiGSgRG9ucCrQJ870Q4FTDrgaERGRDBbq7Fkzi70L0PFmtjXmfW/gDILrNUVERHqssJec1BGcAOTAs3Hm7wKuSlZRIiIimShsaI4kuG3eWuBE4N2YebuBze7eluTaREREMkqo0HT3t6IvE35otYiISE8R5uYG5wG/d/dPoq875e5PJq0yERGRDBNmpPkbYCiwOfq6M05wUpCIiEiPFObmBr3ivRYREck2CkEREZGQwh7TDEXHNEVEpCcLe0wzDB3TFBGRHi2hY5oiIiLZTIEoIiISkq7TFBERCUnXaYqIiISk6zRFRERCUgiKiIiElHBomlmlmT1kZnXRr4c7PG9TRESkR0ooNM3sQuBVYBjwVPRrCLDUzL4Zch2Xm1mjmX1sZsvM7JQu2o4wM4/zdWaHdhOj6/rYzNaa2cxEtktERCSMsM/TbPevwA3u/pPYiWb2j8CPgV91tbCZTQHuAC4HlkS/P21mY9397S4WPRNYHvN+a8w6RxKE938A3wTGA7PM7F13fyLshomIiOxPortnjwQeizP9cSAvxPLXAg+4+xx3f8PdrwI2ApftZ7kt7r4p5mt3zLyZwDvuflV0nXOAB4HrQ9QjIiISWqKh+RJwapzppwILu1rQzPoAJwDPdpj1LPCl/fzcJ81ss5m9bGZ/02FedZx1PgNEzOyQ/axXREQktERv2P40cJOZRYBXotNOAs4DfrifVQ0muI6zucP0ZuD0TpbZSTBifBloBSYDj5rZxe7evit4KPB8nHXmRH/mxg7bcylwKUB+fj4LFiwAoKioiMMPP5zly4O9wIMGDaK0tJRFixYBkJOTw/jx46mvr2f79u0ARCIRmpubgWP2s+kHj/Z/j7KyMlpaWmhoaACgsLCQIUOGUFdXB0D//v2prKxkyZIltLa2AjBhwgRWrlzJli1bACgvL2fHjh2sXbsWgBEjRjBw4EDq6+sBGDBgAOXl5SxcuBB3x8yYOHEiy5cvZ9u2bQBUVlaydetW1q1bBxxYP61fvx6AUaNGkZuby4oVKwDIy8tj9OjRLFmyBIDc3Fyqq6upq6tj586dAFRVVbFhwwaampoAKCkpoXfv3qxatQqAoUOHMnLkSGpqagDo27cvVVVV1NbWsmvXLgCqq6tpbGxk06ZNAIwdO5a2tjZWr14NwPDhwykoKKC2thaAfv36EYlEqKmpoaWlBYDx48ezZs0aNm/erH5SP6mfuqmfumLu3nUDs0+7bPAZd/dOb25gZvlAEzDB3RfHTP9nYKq7jwnzQ8xsFjDe3Y+Pvl8DPOzu/xLTZiKwABjm7ps6W1ckEvH2X9oDMeP2A15FxphzTborEBFJLzNb5u6RePP2u3vW3XuF/Nrf3YDeA9oIRoax8th39NmVWmBUzPtNnayzFdiSwHpFRES6lLKbG0RP3lkGTOowaxLwxwRWVcHeu1xr2Hf37iSgzt0/SbBMERGRTiV6yQlmNpDgEpCjgD6x89z9R/tZ/DbgYTNbSnCcciaQD8yOrvsm4ER3Py36/mLgE+BPwKfAV4ErgO/GrHM2cKWZ3Q78EjgZmAZMTXTbREREupJQaJrZScAfgBaCy0+aCG500AKsA7oMTXd/1MwGAT+ILrcCOMvd34o2Gca+Z9X8ADiaYNfuGmB6zElAuHujmZ0F/BvBpSvvAFfrGk0REUm2REeatwC/Bv4e2A78JfAh8AhwX5gVuPssYFYn86Z1eP8gwTWX+1vnQkC38hMRkW6V6DHN44G7PDjltg3Idfdmgt2lP0xybSIiIhkl0dCMvRNPM8FuUwiup8xPSkUiIiIZKtHds/XAOIJjiwuAH5vZEIJ7vr6W3NJEREQyS6Ijze8TnGgDwQk67wJ3AgOI3mVHRESkp0popOnudTGv3wX+KukViYiIZKiEr9MEMLNjgGOjb1e5+9rklSQiIpKZEr1OcxDBpSWTCW42EJ1s/01w/aRuWyciIj1Wosc0/x0oBk4BDo1+TQBGAnOSW5qIiEhmSXT37BnAae5eEzPtZTP7P+z7eC4REZEeJdGR5rsEdwDq6CP0RBEREenhEg3NHwG3m9nw9gnR1z9nP/edFREROdjtd/esmb0OxD6peiSwzsyaou+HAx8TPMPy35NeoYiISIYIc0zzN91ehYiIyEFgv6Hp7jemohAREZFM93lvbvCXwFiC3bYr3X1BMosSERHJRIne3GA48FvgBD67B22+mdUB57r7O50uLCIicpBL9OzZXxA8R7PY3QvdvRAYFZ32i2QXJyIikkkS3T07CTjV3RvbJ7j7WjO7GnghqZWJiIhkmERHmp35dP9NREREDm6JhuYLwC/MrLB9gpkdBdyBRpoiItLDJRqaVwOHAWvN7C0zWwf8OTrt6iTXJiIiklESPaa5BTgR+DIwBjCC52nqZu0iItLjhQ5NM+sNfACUu/tzwHPdVpWIiEgGCr171t3bgLeAPt1XjoiISOZK9JjmvwA3m9ng7ihGREQkkyV6TPN6gqecNJnZBjo8W9Pdj09WYSIiIpkm0dD8DcH9Zq0bahEREclooULTzA4DbgHOAQ4huCbzKnd/r/tKExERySxhj2neCEwD/gA8ApwO3NNNNYmIiGSksLtnzwMucfe5AGb2a+BlM+sdPatWRESkxws70iwEFre/cfelQCuQ3x1FiYiIZKKwodkb2N1hWiuf8yHWIiIiB6OwoWfAr8ysJWbaocAcM/uofYK7T05mcSIiIpkkbGg+GGfar5JZiIiISKYLFZru/nfdXYiIiEimS9ZDqEVERHo8haaIiEhICk0REZGQFJoiIiIhKTRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkJIWmiIhISApNERGRkBSaIiIiISk0RUREQlJoioiIhKTQFBERCUmhKSIiEpJCU0REJCSFpoiISEgKTRERkZAUmiIiIiGlPDTN7HIzazSzj81smZmd0kXbU81snpltNLOPzOw1M5sep43H+RrT/VsjIiLZJKWhaWZTgDuAnwBfBP4IPG1mR3WyyJeA14G/AcqAe4B7zewbcdqWAsNivhqSW72IiGS7nBT/vGuBB9x9TvT9VWZ2JnAZ8I8dG7v7TzpMusfMvgx8HfjPDvM2u/t7yS5YRESkXcpGmmbWBzgBeLbDrGcJRpRh9Qe2xZleF92N+0I0WEVERJIqlSPNwUBvoLnD9Gbg9DArMLO/Bk4DTo6ZvJFgpPoq0Af4FvCCmZ3q7ovirONS4FKA/Px8FixYAEBRURGHH344y5cvB2DQoEGUlpayaFGwipycHMaPH099fT3bt28HIBKJ0NzcDBwTpvyDQvu/R1lZGS0tLTQ0BHu5CwsLGTJkCHV1dQD079+fyspKlixZQmtrKwATJkxg5cqVbNmyBYDy8nJ27NjB2rVrARgxYgQDBw6kvr4egAEDBlBeXs7ChQtxd8yMiRMnsnz5crZtCz4XVVZWsnXrVtatWwccWD+tX78egFGjRpGbm8uKFSsAyMvLY/To0SxZsgSA3NxcqqurqaurY+fOnQBUVVWxYcMGmpqaACgpKaF3796sWrUKgKFDhzJy5EhqamoA6Nu3L1VVVdTW1rJr1y4AqquraWxsZNOmTQCMHTuWtrY2Vq9eDcDw4cMpKCigtrYWgH79+hGJRKipqaGlpQWA8ePHs2bNGjZv3qx+Uj+pn7qpn7pi7t5lg2Qxs3ygCZjg7otjpv8zMNXduzxxx8xOBp4Gvuvu9+yn7VNAq7tP7qpdJBLx9l/aAzHj9gNeRcaYc026KxARSS8zW+bukXjzUnki0HtAGzC0w/Q89h197sXMxhME5j/tLzCjaoFRn6dIERGRzqQsNN19N7AMmNRh1iSCs2jjMrMJBIF5o7vfHvLHVRDsthUREUmaVJ89exvwsJktBV4GZgL5wGwAM7sJONHdT4u+PxX4AzAL+LWZtY9S29z93Wiba4B1wEqCY5rfBM4hOMNWREQkaVIamu7+qJkNAn5AcC3lCuAsd38r2mQYe59VMw04DLg++tXuLWBE9HUf4FZgOLCLIDzPdvenumcrREQkW6V6pIm7zyIYOcabNy3O+2nx2sa0+Rnws+RUJyIi0jnde1ZERCQkhaaIiEhICk0REZGQFJoiIiIhKTRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkJIWmiIhISApNERGRkBSaIiIiISk0RUREQlJoioiIhKTQFBERCUmhKSIiEpJCU0REJCSFpoiISEgKTZGo+fPnU1JSQnFxMTfffPM+8998802qq6vJzc3l1ltv3Wve9OnTycvLo6ysbK/pU6ZMoaKigoqKCkaMGEFFRUV3boKIdLOcdBcgkgna2tq44ooreO655ygoKGDcuHFMnjyZsWPH7mkzcOBAfvGLX/C73/1un+WnTZvGlVdeyUUXXbTX9EcffXTP6+uuu44jjjii27ZBRLqfRpoiwNKlSykuLqaoqIg+ffpwwQUXMG/evL3a5OXlMW7cOA455JB9lp8wYQIDBw7sdP3uzmOPPcbUqVOTXruIpI5CUwRoamqisLBwz/uCggKampqStv7FixczZMgQRo0albR1ikjqKTRFCEaCHZlZ0tb/yCOPaJQp0gPomKYIwchy/fr1e95v2LCB/Pz8pKy7tbWVJ598kmXLliVlfSKSPhppigDjxo2joaGBxsZGdu/ezdy5c5k8eXJS1v38888zZswYCgoKkrI+EUkfhaYIkJOTw1133cUZZ5zBsccey/nnn09paSmzZ89m9uzZAGzatImCggJuu+02fvzjH1NQUMD27dsBmDp1KtXV1axevZqCggLuu+++PeueO3euds2K9BAW71hOtohEIl5XV3fA65lx+4HXkinmXJPuCkRE0svMlrl7JN48jTRFRERC0olA0mP1lD0AGv2LZA6NNEVEREJSaIqIiISk0BQREQlJoSkiIhKSQlNERCQkhaaIiEhICk0REZGQFJoiIiIhKTRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkJIWmiIhISApNERGRkBSaIiIiISk0RUREQlJoiohIQubPn09JSQnFxcXcfPPN+8x3d66++mqKi4s5/vjjqa+v3zNv+vTp5OXlUVZWts9yd955JyUlJZSWlvKd73ynW7fh81JoikhG644/0Fu3bmXSpEmMGjWKSZMmsW3btm7fjp6ira2NK664gqeffppVq1bxyCOPsGrVqr3aPP300zQ0NNDQ0MC9997LZZddtmfetGnTmD9//j7rfemll5g3bx6vvfYaK1eu5Prrr+/2bfk8FJoikrG66w/0zTffzGmnnUZDQwOnnXZa3DCW+JYuXUpxcTFFRUX06dOHCy64gHnz5u3VZt68eVx00UWYGSeddBLvv/8+GzduBGDChAkMHDhwn/Xec889fO973yM3NxeAvLy87t+Yz0GhKSIZq7v+QM+bN4+LL74YgIsvvpjf/e533b4tPUVTUxOFhYV73hcUFNDU1JRwm47WrFnD4sWLqaqqYuLEibz66qvJLTxJFJoikrG66w90c3Mzw4YNA2DYsGFs3rw5iVX3bO6+zzQzS7hNR62trWzbto1XXnmFW265hfPPPz/uetJNoSkiGau7/kDL51dQUMD69ev3vN+wYQP5+fkJt4m33vPOOw8z48QTT6RXr1689957yS0+CRSaIpKxuusP9JAhQ/bswt24cWPGHj/LROPGjaOhoYHGxkZ2797N3LlzmTx58l5tJk+ezEMPPYS788orr3DEEUfsGdl35pxzzuHFF18Egl21u3fvZvDgwd22HZ+XQlNEMlZ3/YGePHkyDz74IAAPPvggX/va17ptG3qanJwc7rrrLs444wyOPfZYzj//fEpLS5k9ezazZ88G4KyzzqKoqIji4mJmzJjBrFmz9iw/depUqqurWb16NQUFBdx3331AcKbz2rVrKSsr44ILLuDBBx/MyD0Glon7jFMlEol4XV3dAa9nxu0HXkummHNNuitInp7SLz2pTz6Pp556imuuuYa2tjamT5/O97///T1/nGfOnIm7c+WVVzJ//nwOO+ww7r//fiKRCBD8gV6wYAHvvfceQ4YM4cYbb+SSSy5hy5YtnH/++bz99tscddRRPP7443FPGJLsZGbL3D0Sd55CU6EZqyf9ge4p/dKT+kQyT0/5fwLJ+7/SVWimfPesmV1uZo1m9rGZLTOzU/bT/jgzW2hmu8ysycz+yTqM2c1sYnRdH5vZWjOb2b1bISIi2SgnlT/MzKYAdwCXA0ui3582s7Hu/nac9v2B54BFwDigBHgA+BD4ebTNSOAp4D+AbwLjgVlm9q67P9Hd2yQi4WlUIwe7VI80rwUecPc57v6Gu18FbAQu66T9hcBhwMXuviIagj8Fro0Zbc4E3nH3q6LrnAM8CGTmPZhEROSglbJjmmbWB/gImOruj8dMvxsoc/eJcZZ5CBjk7mfHTBsHLAWK3L3RzBYBr7v7FTFt/hb4T+Awd/+kwzovBS6Nvi0BVidrG7vZYCDzLloS9UvmUZ9kpoOpX4529yPjzUjl7tnBQG+gucP0ZuD0TpYZCmyI0759XmP0+/Nx2uREf+bG2Bnufi9wbyKFZwIzq+vswLSkj/ol86hPMlNP6Zd0XKfZcWhrcabtr33H6WHaiIiIHJBUhuZ7QBvByDBWHvuOPttt6qQ9Mct01qYV2PK5KhUREYkjZaHp7ruBZcCkDrMmAX/sZLEa4BQzO7RD+3eAdTFtOu7enQTUdTyeeZA76HYpZwn1S+ZRn2SmHtEvKb25QfSSk4cJLjV5meDM10uAUnd/y8xuAk5099Oi7Y8gOFFnAfBjYDTBJSc3unvsJScrgDnAL4GTgVkEJxzpkhMREUmalF6n6e6Pmtkg4AfAMIKwO8vd34o2GQYcE9P+AzObBNwN1AHbCK7PvC2mTaOZnQX8G8GlK+8AVyswRUQk2bL6NnoiIiKJ0FNOREREQlJoioiIhKTQFJEeo/32mh0f6iCSLDqmmcHMbCwwFjiC4Cb1te7emN6qRA4e7eHp+kMnSaLQzFBm9j2CG9aPApoIbtTwKfAngvvqvkzwt0AdmCJmdjSwxd13prsW2ZuZ9QK+BhxJ8JCHJmChu29Oa2HS4yg0M1D0spx1wD+4+2wzKwROBKqBE4BDgX909wVpKzLLmNkA4E2CDytPAIuBjXEeCHAy8L/u3tldriTJzOxw4D7gywQfLDcQ3EJzF7AQ+JW7v2lmpg+ZqWFmhwAjgbfcvSXd9SSTjmlmpr8F3nT32QDuvt7dn3D364FrCD5F/5eZFaWxxmxzIXAI0I/g2a11wGwzO8PMjjSzXtEPN/cDA9JYZza6muCJRWe5+xCCvrodWAmcAfzMzI5UYKbUFQR7xWab2VfNbKiZ9Y5tYGb9zeyvogF70NBIMwNFH232M4LniC5q/2Vz97bo/EMJ7pL0kLvPSluhWST6CLscghto/AVwEfB3QCXwv8CjBLsFL3H3L6SpzKxkZouB37r7bR2m9ya4Q9h9wJ/d/cx01JeNzKwG+Jjg/8yXgLeB3wJPEjzK8QMzmwlMc/eT0ldp4jTSzEx/AN4CrjOz49y9rT0wAdz9Y4Ib0g9KV4HZJPpJuIZg96y5+w53vzv6mKPRwGPABcD/BW5NX6XZx8xyCO4s9nUzOzI6rbeZ9Y7+v1lEcLvOAjMrT2et2SLaD58Ac9z9FOBogg8ufw0sAl40s+8S7DWrTVedn5dGmhmm/bhL9NjYncBxwNMEv3SvAQMJPrn9CPiiu69LV63ZJBqc/dx9W3QE0wv4NGb0P4Zgd+DR7t7xGbDSjczsJODXwG+A2zoeT47uNn8DKHH3pjSUmFXMbBjBh8hV7v5Mh3lfBL4dnT8AKDzY+kShmaHMrD+QS3Diz7eAs6PvNxGMMu9y9zvSV2H2iPkgcwywI/aMTDPr5e6fmtkNwAx3Pyp9lWaf6FmzvQh2lf+EYHfgbwh2l68Hjge+Chzr7uPSVWe2MbO+BGf3fxx7zWz7cWUz+1eCY9BfTFeNn5dCM4OYWR5BQF4LbCU4JvAOwe7aF4EvAEcBL+vszNTo0CebCT6wbAQeB5509w+j7c4Gdrr7wnTVmu3M7AvANOAbQAWwA2gBlgI3uftBtyvwYNbZ2cpmdhhQD9zv7j9NfWUHRqGZQczsAaAU+D1BaA4EyoExBOH5/9z91bQVmIU66ZMvEvTJBuAWd382bQVmsejemB2xf5ijI89DCc5yLgM+VFimTrw+idPmUGAK8Ej0OcsHFYVmhojuwthBsMtiUcy0o4AqguMARcDfuvuf0lZoFumiTwoJ+mQGwUkOF6hPUs/MfkkwilxKcD3g9jhtBkSPQ+sazRQI2SdfcPf3U11bsujs2cwxFmgE9nzy8sBb7v4YwZln7wPnp6e8rNRZn7zt7o8T9MkO1CcpZ2ZTCT60/ByYB9xiZueZWXH0eBpm1g+4P3oGugKzm3XSJ+ea2TExfdIXeNDMytJY6gHRSDNDRH+Z/pvgWr+LCK4r+7RDm6sIrgOsSH2F2Ud9krnMbA7QRnA983nAxQQPsF8NPAW8QHDDgzvcvU+66swm2dInGmlmCHffBXwf6As8BFxkZoVm9hew5+D5RIJr0iQF1CeZKXptZiPwvruvdfdb3f04YBzBbfMuJrh29k7g4fRVmj2yqU800sww0d0WNwCTCZ5sUgO8C5xOcNbmt9399fRVmH3UJ5knei/gIdF7yvYBPulwQtAU4BGg0t3/J01lZpVs6ROFZoaKXupwNnAOwaUnK4DH3f3NdNaVzdQnmS165qy5e5uZzSDYDXhYuuvKZj2xTxSaB4H2C+jTXYd8Rn2S2czsWqC3u9+S7lok0FP6RKEpIj1O9LaHbfpgkzl6Sp8oNEVERELS2bMiIiIhKTRFRERCUmiKiIiEpNAUEREJSaEpIiISkkJTREQkpP8PcbNMGOEawAAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eb5f1be-f92b-4728-aaad-32e0505ef120",
   "metadata": {},
   "source": [
    "Since $A$ corresponds to the probability amplitudes, we plot the square of the data (normalised) to see the expected probability distribution. In the same graph, we plot selected states from `counts` which have `flag` = $0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fc4fb8bd-7f95-47a6-86c1-07b3ba11354d",
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_counts = {}\n",
    "for k in counts.keys():\n",
    "    # Store in dict if flag bit is 0\n",
    "    if k[0] == '0':\n",
    "        selected_counts[k[1]] = counts[k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bc513a3b-265f-4e88-8db9-7d918517b0a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "A_dict = {}\n",
    "for i in range(m):\n",
    "    A_dict[bin(i)[2:].rjust(d, '0')[::-1]] = (A_vals[i])**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0615c7a6-4d25-46bf-8fdd-b7013594d51b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram([selected_counts, A_dict], legend = [\"Counts\", \"Expected\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3bf0b1-9554-482b-ab9c-cd2b32c1aa36",
   "metadata": {},
   "source": [
    "# Modified state preparation algorithm (without arithmetic)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67386adc-2b0c-4b38-a235-e73c5e3f1761",
   "metadata": {},
   "source": [
    "#### Step 1 - Initialization\n",
    "\n",
    "The circuit is initialized with `out`, `data`, `ref` and `flag` registers, and with `out` register in equal superposition (to represent indices).\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_0\\rangle &= H^{\\otimes d}|0^{\\otimes d}\\rangle_{out} \\otimes |0^{\\otimes n}\\rangle_{data} \\otimes |0^{\\otimes n}\\rangle_{ref} \\otimes |0\\rangle_{flag} \\\\\n",
    "|\\psi_0\\rangle &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|0^{\\otimes n}\\rangle_{data}|0^{\\otimes n}\\rangle_{ref}|0\\rangle_{flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $M = 2^d$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "04de210b-8e37-4041-9de5-84d9af78718f",
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_modified = initializer(A, d, m, n, True)\n",
    "sv_modified_0 = Statevector.from_instruction(qc_modified) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b61f9c61-5aad-4660-9f92-72c6f416fa6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '000', '000', '0', '0.70710678', '0.50000000'),\n",
       " ('1', '000', '000', '0', '0.70710678', '0.50000000')]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_0, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03d88ec5-b61f-41ec-9e62-7f616e2a8c1c",
   "metadata": {},
   "source": [
    "#### Step 2 - Apply black box `amp`\n",
    "\n",
    "Next, the oracle is applied on the circuit, which prepares the system in the state \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_1\\rangle &= (amp \\otimes I_{n+1}) |\\psi_0\\rangle \\\\\n",
    "|\\psi_1\\rangle &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}|0^{\\otimes n}\\rangle_{ref} |0\\rangle_{flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "$amp$ has the following action - \n",
    "$$amp|i\\rangle|z\\rangle = |i\\rangle|z \\oplus a_{i}^{(n)}\\rangle $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3170eb01-3474-49f7-a75b-5aaee1602b04",
   "metadata": {},
   "outputs": [],
   "source": [
    "black_box = oracle(A, d, m, n)\n",
    "qc_modified.append(black_box, qargs = [i for i in range(0,d+n)])\n",
    "sv_modified_1 = Statevector.from_instruction(qc_modified) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2f3db792-578b-4a42-a205-7d79cc75aec3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '000', '0', '0.70710678', '0.50000000'),\n",
       " ('1', '001', '000', '0', '0.70710678', '0.50000000')]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_1, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "443b18d0-5c33-420e-97ef-77cea2e83317",
   "metadata": {},
   "source": [
    "#### Step 3 - Prepare `ref` in an equal superposition\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_2\\rangle &= (I_{d+n} \\otimes H^{\\otimes n} \\otimes I_{1}) |\\psi_1\\rangle \\\\\n",
    "|\\psi_2\\rangle &= \\frac{1}{\\sqrt{MN}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}\\Biggl(\\sum_{j=0}^{N - 1} |j\\rangle_{ref} \\Biggr) |0\\rangle_{flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $N = 2^n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7eadb72c-2f01-4f42-9dbc-3dfccc43a5a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_modified.h([i for i in range(d+n, d+2*n)])\n",
    "sv_modified_2 = Statevector.from_instruction(qc_modified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1b0dc44c-9784-48d5-b96e-fb27c73e4757",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '000', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '100', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '010', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '110', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '001', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '101', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '011', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '111', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '000', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '100', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '010', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '110', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '001', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '101', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '011', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '111', '0', '0.25000000', '0.06250000')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_2, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ed7f9b7-5b1a-42db-8227-1351ee56da41",
   "metadata": {},
   "source": [
    "#### Step 4 - Perform compare operation\n",
    "\n",
    "The $comp$ operator is applied on the system, which results in the following state\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_3\\rangle &= comp|\\psi_2\\rangle \\\\\n",
    "|\\psi_3\\rangle &= \\frac{1}{\\sqrt{MN}}\\sum_{i=0}^{M - 1}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}\\Biggl( \\sum_{j=0}^{a_{i}^{n} - 1} |j\\rangle_{ref} |0\\rangle_{flag} + \\sum_{j=a_{i}^{n}}^{N - 1} |j\\rangle_{ref} |1\\rangle_{flag}\\Biggr) \n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "That is, of the prepared superposition states in `ref`, if the state is $\\geq a_i$ for that value of $i$, then the corresponding qubit in `flag` is flipped to the $1$ state.\n",
    "\n",
    "\n",
    "In the case of the toy example, we have \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_3\\rangle &= \\frac{1}{2}|0\\rangle_{out}|011\\rangle_{data}\\Biggl[\\frac{1}{2\\sqrt{2}}\\Bigl(|000\\rangle_{ref} + |001\\rangle_{ref} + |010\\rangle_{ref} \\Bigr)|0\\rangle_{flag} + \\frac{1}{2\\sqrt{2}}\\Bigl(|011\\rangle_{ref} + |100\\rangle_{ref} + |101\\rangle_{ref} + |110\\rangle_{ref} + |111\\rangle_{ref} \\Bigr)_{ref}|1\\rangle_{flag}\\Biggr] \\\\\n",
    "               &+ \\frac{1}{2}|1\\rangle_{out}|001\\rangle_{data}\\Biggl[\\frac{1}{2\\sqrt{2}}\\Bigl(|000\\rangle_{ref} \\Bigr)|0\\rangle_{flag} + \\frac{1}{2\\sqrt{2}}\\Bigl(|001\\rangle_{ref} + |010\\rangle_{ref} + |011\\rangle_{ref} + |100\\rangle_{ref} + |101\\rangle_{ref} + |110\\rangle_{ref} + |111\\rangle_{ref} \\Bigr)_{ref}|1\\rangle_{flag}\\Biggr]\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3e533450-b0b7-4b38-85b5-c5c1f6048e35",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare(A_vals_n, d, m, n):\n",
    "    circ = QuantumCircuit(d+n+1, name = \"comp\")\n",
    "    # circ.h([i for i in range(d, d+n)])\n",
    "    dec = 2**n\n",
    "    for i in range(m):\n",
    "        for j in range(int(A_vals_n[i]*dec), dec):\n",
    "            circ.append(MCXGate(num_ctrl_qubits = d+n, ctrl_state = ((bin(i)[2:].rjust(d, '0') + bin(j)[2:].rjust(n, '0'))[::-1])), [k for k in range(d+n+1)])\n",
    "        circ.barrier()\n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1141e8ff-6e22-424e-be0c-37aadae432c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "comp = compare(A_vals, d, m, n)\n",
    "qc_modified.append(comp, qargs = [i for i in range(0,d)] + [i for i in range(d+n, d+2*n+1)])\n",
    "sv_modified_3 = Statevector.from_instruction(qc_modified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "f8a5139e-7862-441e-8000-b5670bd5bfca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '000', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '010', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '001', '0', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '100', '1', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '110', '1', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '101', '1', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '011', '1', '0.25000000', '0.06250000'),\n",
       " ('0', '011', '111', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '000', '0', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '100', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '010', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '110', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '001', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '101', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '011', '1', '0.25000000', '0.06250000'),\n",
       " ('1', '001', '111', '1', '0.25000000', '0.06250000')]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_3, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db56787-ea6c-4aa6-a469-e90e34845c2b",
   "metadata": {},
   "source": [
    "#### Step 5 - Unprepare uniform superposition in `ref`\n",
    "\n",
    "We now unprepare the uniform superposition on `ref` by reapplying the Hadamard transform on the register. Since there are $a_l^{(n)}$ states in the superposition that are entangled with the flag register in the $0$ state, the Hadamard transform will result in exactly $a_l^{(n)}$ states with `ref` and `flag` registers in state $|0^n\\rangle_{ref}|0\\rangle_{flag}$. The system now has the final desired state, and some unwanted states. Thus, we use the states which have `ref` and `flag` registers as all-zeroes as the good states in amplitude amplification.\n",
    "\n",
    "The state of the system is now \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "|\\psi_4\\rangle &= (I_{d+n} \\otimes H^{\\otimes n} \\otimes I_{1}) |\\psi_3\\rangle \\\\ \\\\\n",
    "               &= \\frac{1}{\\sqrt{M}}\\sum_{i=0}^{M - 1}\\frac{a_l^{(n)}}{N}|i\\rangle_{out}|a_{i}^{(n)}\\rangle_{data}|0^{\\otimes n}\\rangle_{ref} |0\\rangle_{flag} + |\\omega\\rangle_{out \\otimes data \\otimes ref \\otimes flag}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $|\\omega\\rangle$ is the unwanted, unnormalised state that we will be 'supressed' during amplitude amplification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a8e06841-4590-4e6b-ab01-ada638499c3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "qc_modified.h([i for i in range(d+n, d+2*n)])\n",
    "sv_modified_4 = Statevector.from_instruction(qc_modified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c24cf7d8-1379-496c-a363-829ee02b9b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '000', '0', '0.26516504', '0.07031250'),\n",
       " ('0', '011', '100', '0', '0.26516504', '0.07031250'),\n",
       " ('0', '011', '010', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '110', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '001', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '101', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '011', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '111', '0', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '000', '1', '0.44194174', '0.19531250'),\n",
       " ('0', '011', '100', '1', '0.26516504', '0.07031250'),\n",
       " ('0', '011', '010', '1', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '110', '1', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '001', '1', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '101', '1', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '011', '1', '0.08838835', '0.00781250'),\n",
       " ('0', '011', '111', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '000', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '100', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '010', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '110', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '001', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '101', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '011', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '111', '0', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '000', '1', '0.61871843', '0.38281250'),\n",
       " ('1', '001', '100', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '010', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '110', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '001', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '101', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '011', '1', '0.08838835', '0.00781250'),\n",
       " ('1', '001', '111', '1', '0.08838835', '0.00781250')]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_4, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "29d5513b-d70e-4c91-baa4-6853fb565670",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 481.547x505.68 with 1 Axes>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc_modified.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcf607d3-1b56-4aa9-b697-9453b11899f8",
   "metadata": {},
   "source": [
    "#### Step 6 - Perform amplitude amplification\n",
    "\n",
    "The system now contains the target state, which has the data elements as amplitudes of the basis vectors. However the system also has some unwanted states (where `ref ` and `flag` register are non-zero). To eliminate these states and increase the probability of the desired state, we perform amplitude amplification on the state $|\\psi_4\\rangle$. After amplitude amplification, we will be left with a superposition of the desired state, and an undesired state, which has a small probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f1df07e3-1bf9-4021-b7c9-6eecef1c7a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('aer_simulator')\n",
    "quantum_instance = QuantumInstance(backend)\n",
    "\n",
    "problem = AmplificationProblem(oracle = phase_oracle(d, n, True), state_preparation = qc_modified, objective_qubits = [i for i in range(0,d+2*n+1)], is_good_state = ['00110000', '10010000'])\n",
    "grover = Grover(quantum_instance=quantum_instance)\n",
    "\n",
    "out = QuantumRegister(d, name = \"out\")\n",
    "data = QuantumRegister(n, name = \"data\")\n",
    "ref = QuantumRegister(n, name = \"ref\")\n",
    "flag = QuantumRegister(1, name = \"flag\")\n",
    "check = ClassicalRegister(d+n+1, name = \"check\")\n",
    "\n",
    "modified_state_prep = QuantumCircuit(out, data, ref, flag, check)\n",
    "# modified_state_prep = qc_modified\n",
    "\n",
    "modified_state_prep.append(grover.construct_circuit(problem, power = 2), [i for i in range(0, d+2*n+1)])\n",
    "    \n",
    "sv_modified_5 = Statevector.from_instruction(modified_state_prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4734a7b2-84c6-4d49-85d0-0cf5998f6536",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '011', '000', '0', '0.93739986', '0.87871850'),\n",
       " ('0', '011', '100', '0', '0.04246784', '0.00180352'),\n",
       " ('0', '011', '010', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '110', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '001', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '101', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '011', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '111', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '000', '1', '0.07077973', '0.00500977'),\n",
       " ('0', '011', '100', '1', '0.04246784', '0.00180352'),\n",
       " ('0', '011', '010', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '110', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '001', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '101', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '011', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '011', '111', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '000', '0', '0.31246662', '0.09763539'),\n",
       " ('1', '001', '100', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '010', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '110', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '001', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '101', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '011', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '111', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '000', '1', '0.09909162', '0.00981915'),\n",
       " ('1', '001', '100', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '010', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '110', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '001', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '101', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '011', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '001', '111', '1', '0.01415595', '0.00020039')]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(get_sv(sv_modified_5, True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87895bc6-f737-47e6-a7f6-1958364a3e0d",
   "metadata": {},
   "source": [
    "#### Step 7 - Unprepare `data` register\n",
    "The `data` register is 'unprepared' by applying the oracle again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "62530fc2-4b11-46d6-ae3a-bd9e923a888d",
   "metadata": {},
   "outputs": [],
   "source": [
    "modified_state_prep.append(black_box, qargs = [i for i in range(0, d+n)])\n",
    "sv_modified_6 = Statevector.from_instruction(modified_state_prep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3df23ce0-3273-4cc5-a548-c8c5cb887323",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Out   Data   Ref  Flag  Amplitude           Probability\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('0', '000', '000', '0', '0.93739986', '0.87871850'),\n",
       " ('0', '000', '100', '0', '0.04246784', '0.00180352'),\n",
       " ('0', '000', '010', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '110', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '001', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '101', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '011', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '111', '0', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '000', '1', '0.07077973', '0.00500977'),\n",
       " ('0', '000', '100', '1', '0.04246784', '0.00180352'),\n",
       " ('0', '000', '010', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '110', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '001', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '101', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '011', '1', '0.01415595', '0.00020039'),\n",
       " ('0', '000', '111', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '000', '0', '0.31246662', '0.09763539'),\n",
       " ('1', '000', '100', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '010', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '110', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '001', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '101', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '011', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '111', '0', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '000', '1', '0.09909162', '0.00981915'),\n",
       " ('1', '000', '100', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '010', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '110', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '001', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '101', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '011', '1', '0.01415595', '0.00020039'),\n",
       " ('1', '000', '111', '1', '0.01415595', '0.00020039')]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_sv(sv_modified_6, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "931b2355-89e8-4852-974e-21cbdecfe82c",
   "metadata": {},
   "source": [
    "#### Step 8 - Measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "44513bd1-299b-460a-b5ea-d6800ef33827",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 662.722x565.88 with 1 Axes>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modified_state_prep.measure([out[i] for i in range(d)] + [ref[i] for i in range(n)] + [flag[0]], check)\n",
    "modified_state_prep.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b5deea4-6b17-433c-be13-7354a8e60484",
   "metadata": {},
   "source": [
    "The algorithm is successful if the `ref` and `flag` register result in $0^{n+1}$. In this case, the system collapses to the desired state. We observe that the states with value of `ref` and `flag` as $0^{n+1}$ have high probability after amplitude amplification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6f90fd2c-36fa-4f79-8be4-75533d4afa44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'10001': 13, '00000': 871, '11000': 1, '00001': 102, '10000': 3, '01110': 1, '10010': 1, '10110': 1, '00010': 4, '00100': 1, '11100': 1, '01111': 1}\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('aer_simulator')\n",
    "\n",
    "modified_res = execute(modified_state_prep, backend, shots=1000).result()\n",
    "modified_counts = modified_res.get_counts()\n",
    "print(modified_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "de87acb3-e46a-4ee5-9de2-fed2e6fba859",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(modified_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a148726a-e9b4-4b55-bc47-ec8ad9eee4ae",
   "metadata": {},
   "source": [
    "Since $A$ corresponds to the probability amplitudes, we plot the square of the data (normalised) to see the expected probability distribution. In the same graph, we plot selected states from `counts` which have `ref` and `flag` = $0^{n+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "da1596f5-420c-48e1-a7ae-1a31d977e8d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_modified_counts = {}\n",
    "for k in modified_counts.keys():\n",
    "    # Store in dict if ref and flag bits are all 0\n",
    "    if k[0:n+1] == '0'*(n+1):\n",
    "        selected_modified_counts[k[n+1:]] = modified_counts[k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "dec13dc6-ae8f-4f42-b862-7990198ba149",
   "metadata": {},
   "outputs": [],
   "source": [
    "A_dict = {}\n",
    "for i in range(m):\n",
    "    A_dict[bin(i)[2:].rjust(d, '0')[::-1]] = (A_vals[i])**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "deb7ab22-c3d2-4507-9c12-cad42df91ba2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram([selected_modified_counts, A_dict], legend = [\"Counts\", \"Expected\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}