examples/fourier_adder/fourier_adder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d_IIrdnTD3Zv"
   },
   "source": [
    "# Quantum Fourier Transform (QFT) in Quantum Computation Theory: Fourier Adder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JI1q6Uboh43r"
   },
   "source": [
    "Students often begin learning classical computing with the addition operation, let's take a look at the addition operation in the quantum world. In the context of the **Quantum Fourier Adder**, the QFT allows for the addition of a specified integer value to an arbitrary bitstring represented by a quantum state. This addition is performed efficiently in the Fourier basis, leveraging the principles of quantum mechanics to achieve computational advantages over classical algorithms for certain tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GmjlxVXrDQvu"
   },
   "source": [
    "Testing the addition operation on a quantum device involves several stages:\n",
    "- Design the quantum algorithm for addition  \n",
    "- Quantum circuit implementation  \n",
    "- Execution on quantum device\n",
    "- Analysis and results validation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fs0KXpTKbuMH"
   },
   "source": [
    "## 1. Purpose and Relevance\n",
    "\n",
    "The Fourier Transform is an essential tool in signal processing. The classical Fourier transform is used to decompose a complex-valued function `f(x)` into its constituent frequencies and their amplitudes, and the inverse Fourier recreates `f(x)` from its transform [1]. It helps to analyze frequencies, filter data, compress information, perform convolution and correlation, conduct spectral analysis.  \n",
    "\n",
    "Similarly, QFT holds great promise for signal processing when applied to quantum computing [2-5]. It opens new possibilities for applications in different fields in quantum information processing, for example:\n",
    "\n",
    "- **Quantum Algorithm Design**: can be used as building block for quantum algorithms (Shor's algorithm for integer factorization, phase estimation, etc.)\n",
    "\n",
    "- **Quantum Cryptography**: the method is used for the quantum key distribution.\n",
    "\n",
    "- **Quantum Simulation**: facilitates the simulation to study quantum materials, chemical reactions, and other complex quantum processesing of physical systems.\n",
    "\n",
    "- **Error Correction**: QFT techniques are essential for developing quantum error correction codes, which are crucial for mitigating errors in quantum computations caused by noise and decoherence.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dUlCVeB7y1zG"
   },
   "source": [
    "## 2. Theory Behind Fourier Adder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hjGInUbobwbS"
   },
   "source": [
    "**Quantum Fourier Transform (QFT)** is a quantum algorithm used to efficiently perform the Fourier transform on a quantum state. The default algorithm for  benchmarking of the quantum Fourier transform and the inverse quantum Fourier transform when applying to the **Fourier Adder** operates as follows [2]:\n",
    "- Initializes qubits with arbitrary bitstring.\n",
    "- Converts to Fourier basis.\n",
    "- Adds specified integer value in Fourier basis (e.g. +1).\n",
    "- Converts back to measurement basis.\n",
    "- Measures initial state plus added integer (x+1).\n",
    "\n",
    "![image.jpg](images/Fig1_QFT_adder.jpg) \n",
    "*Fig.1. Circuit to benchmark Fourier Adder. Initialize inputs to a classical value, perform QFT, rotate the qubits to increase by 1 in the Fourier basis followed by the inverse QFT. It is expected that the measured output would match exactly the input value x+1 to the circuit. This method benchmarks the following circuit. Image sourse: [2]*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To apply Fourier Adder to the particular state - we need to prepare a necessary state using State Circuit, which applies X gates to the corresponding qubits.\n",
    "State Circuit is visible on the left -  \"Encoding x\" part.\n",
    "\n",
    "If we need to apply the Fourier Adder to some other state - we can change the left part - keeping the right part consisting of QFT, Fourier Adder Circuit, Inverse QFT and Measurements.\n",
    "\n",
    "Since only the left part changes for every particular state - we can efficiently apply Rivet Transpile Left function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](images/Fig2_transpilation_time_comparison.png) \n",
    "\n",
    "*Fig.2. Transpilation times comparison for the basic transpilation and transpilation with Rivet function `transpile_left`.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Vhk3ramgby9H"
   },
   "source": [
    "## 3. Installation and Imports\n",
    "\n",
    "\n",
    "The **Rivet Transpiler** package provides a family of functions for the efficient transpilation of quantum circuits.  To benchmark the QFT for the case of addition operation the functions `transpile`, `transpile_left` and  `transpile_right` can be used.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ZgtZj4bhSuh"
   },
   "source": [
    "\n",
    "\n",
    "To run the code below make sure you have followed and installed Rivet transpiler. Check the installation steps from  **Readme.md**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-OxLMF3xhUQv"
   },
   "source": [
    "\n",
    "#### 3.1. Import Qiskit and Rivet Transpiler Functions Required to Run the Examples Below\n",
    "\n",
    "To be able execute code below - `matplotlib` and `tqdm` packages should be installed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install matplotlib\n",
    "# !pip install tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Import Qiskit\n",
    "\n",
    "import qiskit\n",
    "from qiskit.visualization import plot_gate_map\n",
    "from qiskit_ibm_runtime.fake_provider import FakeMontrealV2\n",
    "\n",
    "# General Imports\n",
    "\n",
    "import numpy as np\n",
    "from time import time\n",
    "from tqdm import tqdm\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use(\"dark_background\") # optional, sets dark_background\n",
    "\n",
    "### Import Rivet transpiler functions\n",
    "\n",
    "%cd -q ../..\n",
    "\n",
    "from rivet_transpiler import transpile, transpile_left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ulu8Lq6Ob3r6"
   },
   "source": [
    "#### 3.2. Backend\n",
    "Available backends from IBM Qiskit are listed at [6]. Some backend examples:\n",
    "- 5-qubit backend with noise: `FakeLimaV2`\n",
    "- 32-qubit backend with noise: `FakeMontrealV2` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "backend = FakeMontrealV2() \n",
    "\n",
    "# qiskit.visualization.plot_gate_map(backend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](images/Fig3_FakeMonrealV2_backend.png)\n",
    "\n",
    "*Fig.3. Schematic representation of the FakeMonrealV2 backend.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "COVxHklqb76D"
   },
   "source": [
    "#### 3.3. Define Functions\n",
    "We define here the functions that will be used below.\n",
    "\n",
    "- `build_state_circuit(state)` - constructs a quantum circuit that prepares a specific binary state.\n",
    "\n",
    "- `build_qft_circuit(qubits_count)` - generates QFT circuit of a specified number of qubits.\n",
    "\n",
    "- `build_fourrier_adder(qubits_count, number_to_add=1)` -  constructs a quantum circuit for a Fourier Adder operation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "PtZtEe0bb8E3"
   },
   "outputs": [],
   "source": [
    "def build_state_circuit(state):\n",
    "\n",
    "    qubits_count = len(state)\n",
    "\n",
    "    state_circuit = qiskit.QuantumCircuit(qubits_count)\n",
    "\n",
    "    for index, bit in enumerate(state):\n",
    "\n",
    "        if bit == \"1\":\n",
    "            position = qubits_count - index - 1\n",
    "            state_circuit.x(position)\n",
    "\n",
    "    state_circuit.barrier(label=\"State\")\n",
    "\n",
    "    return state_circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "154Q93rPcA52"
   },
   "outputs": [],
   "source": [
    "def build_qft_circuit(qubits_count):\n",
    "\n",
    "    qubits = list(range(qubits_count))\n",
    "\n",
    "    circuit = qiskit.QuantumCircuit(qubits_count)\n",
    "\n",
    "    for control_qubit in reversed(qubits):\n",
    "\n",
    "        for target_qubit in reversed(range(control_qubit, qubits_count)):\n",
    "\n",
    "            if control_qubit == target_qubit:\n",
    "\n",
    "                circuit.h(control_qubit)\n",
    "\n",
    "            else:\n",
    "\n",
    "                theta = np.pi / 2 ** (target_qubit - control_qubit)\n",
    "\n",
    "                circuit.crz(theta, control_qubit, target_qubit)\n",
    "\n",
    "        circuit.barrier()\n",
    "\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "yzfSDJoHcDAY"
   },
   "outputs": [],
   "source": [
    "def build_fourier_adder(qubits_count, number_to_add=1):\n",
    "\n",
    "    circuit = qiskit.QuantumCircuit(qubits_count)\n",
    "\n",
    "    for qubit in range(qubits_count):\n",
    "\n",
    "        angle = number_to_add * (np.pi / 2 ** qubit)\n",
    "\n",
    "        circuit.rz(angle, qubit)\n",
    "\n",
    "    circuit.barrier(label=\"Adder\")\n",
    "\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5kdKL2DacFU0"
   },
   "source": [
    "## 4. Implementation  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cgj8daoTcFeR"
   },
   "source": [
    "### 4.1. Set up Circuits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "O-2vhR5RcIjD"
   },
   "outputs": [],
   "source": [
    "# Set up parameters\n",
    "\n",
    "QUBITS_COUNT = 5\n",
    "NUMBER_TO_ADD = 2     #  number for addition operation, can set up any integer N\n",
    "\n",
    "EXPERIMENTS_COUNT = 10\n",
    "SHOTS_COUNT = 1000\n",
    "\n",
    "OPTIMIZATION_LEVEL = 3\n",
    "SEED = 1234\n",
    "\n",
    "# States preparation\n",
    "\n",
    "states_count = 2 ** QUBITS_COUNT\n",
    "state_pattern = f\">0{QUBITS_COUNT}b\"\n",
    "\n",
    "states = [f\"{state:{state_pattern}}\" for state in range(states_count)]\n",
    "initial_states = states[:EXPERIMENTS_COUNT]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a4h_BjQDcKTB"
   },
   "source": [
    "Prepares 3 quantum circuits: a QFT circuit, an inverse QFT circuit and a Fourier Adder circuit (with a given `NUMBER_TO_ADD`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "sKkTciYVcNzj"
   },
   "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\">      ┌────────┐ Adder \n",
       "q_0: ─┤ Rz(2π) ├───░───\n",
       "      ├───────┬┘   ░   \n",
       "q_1: ─┤ Rz(π) ├────░───\n",
       "     ┌┴───────┴┐   ░   \n",
       "q_2: ┤ Rz(π/2) ├───░───\n",
       "     ├─────────┤   ░   \n",
       "q_3: ┤ Rz(π/4) ├───░───\n",
       "     ├─────────┤   ░   \n",
       "q_4: ┤ Rz(π/8) ├───░───\n",
       "     └─────────┘   ░   </pre>"
      ],
      "text/plain": [
       "      ┌────────┐ Adder \n",
       "q_0: ─┤ Rz(2π) ├───░───\n",
       "      ├───────┬┘   ░   \n",
       "q_1: ─┤ Rz(π) ├────░───\n",
       "     ┌┴───────┴┐   ░   \n",
       "q_2: ┤ Rz(π/2) ├───░───\n",
       "     ├─────────┤   ░   \n",
       "q_3: ┤ Rz(π/4) ├───░───\n",
       "     ├─────────┤   ░   \n",
       "q_4: ┤ Rz(π/8) ├───░───\n",
       "     └─────────┘   ░   "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qft_circuit = build_qft_circuit(QUBITS_COUNT)\n",
    "\n",
    "inverted_qft_circuit = qft_circuit.inverse()\n",
    "\n",
    "fourrier_adder = build_fourier_adder(QUBITS_COUNT, NUMBER_TO_ADD)\n",
    "\n",
    "fourrier_adder.draw(fold=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KAjq1gmycVLB"
   },
   "source": [
    "### 4.2. Transpilation Speed up with Rivet\n",
    "\n",
    "Here, the results for basic transpilation with the Qiskit and Rivet compilers are compared. We demonstrate the significant speed-up (number of experiments executed per second) in the case of Rivet transpilation implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WD38UJrscVaf"
   },
   "source": [
    "#### 4.2.1. Basic Transpilation with Qiskit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "9q095AqScSWJ"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████| 10/10 [00:01<00:00,  9.00 experiment/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimated_time: 1.12\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "start_time = time()\n",
    "\n",
    "# Compose and Transpile\n",
    "\n",
    "transpiled_circuits = []\n",
    "\n",
    "states_tracker = tqdm(initial_states, unit=' experiment', ncols=110)\n",
    "\n",
    "for initial_state in states_tracker:\n",
    "\n",
    "    state_circuit = build_state_circuit(initial_state)\n",
    "\n",
    "    circuit = state_circuit.compose(qft_circuit)\n",
    "    circuit = circuit.compose(fourrier_adder)\n",
    "    circuit = circuit.compose(inverted_qft_circuit)\n",
    "\n",
    "    circuit.measure_all()\n",
    "\n",
    "    # display(circuit.draw(fold=-1))\n",
    "\n",
    "    transpiled_circuit = qiskit.transpile(\n",
    "        circuit,\n",
    "        backend,\n",
    "        seed_transpiler=SEED,\n",
    "        optimization_level=OPTIMIZATION_LEVEL)\n",
    "\n",
    "    transpiled_circuits.append(transpiled_circuit)\n",
    "\n",
    "estimated_time = time() - start_time\n",
    "\n",
    "print(f\"estimated_time: {estimated_time:.02f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oXLZ4bTscbnY"
   },
   "source": [
    "#### 4.2.2. Rivet Transpilation Using `transpile_left`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "CqAjo2hEccTN"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████| 10/10 [00:00<00:00, 80.42 experiment/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estimated_time: 0.24\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "start_time = time()\n",
    "\n",
    "# Transpile Central Part\n",
    "\n",
    "central_circuit = qft_circuit.compose(fourrier_adder)\n",
    "central_circuit = central_circuit.compose(inverted_qft_circuit)\n",
    "\n",
    "central_circuit.measure_all()\n",
    "\n",
    "transpiled_central_circuit = qiskit.transpile(\n",
    "    central_circuit,\n",
    "    backend,\n",
    "    seed_transpiler=SEED,\n",
    "    optimization_level=OPTIMIZATION_LEVEL)\n",
    "\n",
    "# Transpile Left\n",
    "\n",
    "transpiled_circuits = []\n",
    "\n",
    "states_tracker = tqdm(initial_states, unit=' experiment', ncols=110)\n",
    "\n",
    "for initial_state in states_tracker:\n",
    "\n",
    "    state_circuit = build_state_circuit(initial_state)\n",
    "\n",
    "    # display(circuit.draw(fold=-1))\n",
    "\n",
    "    transpiled_circuit = transpile_left(\n",
    "        transpiled_central_circuit,\n",
    "        left_circuit=state_circuit,\n",
    "        backend=backend,\n",
    "        seed_transpiler=SEED,\n",
    "        optimization_level=OPTIMIZATION_LEVEL)\n",
    "\n",
    "    transpiled_circuits.append(transpiled_circuit)\n",
    "\n",
    "estimated_time = time() - start_time\n",
    "\n",
    "print(f\"estimated_time: {estimated_time:.02f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o-Z6-l_ccgqB"
   },
   "source": [
    "#### 4.2.3. Comparative Analysis of Transpilation Times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K8zINrftcjLf"
   },
   "source": [
    "Here we use the `results` dataset to demonstrate how the transpilation time scales with the number of qubits in cases of basic **Qiskit** transpilation and **Rivet** transpilation using the `transpile_left` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "wTPZe1h4cjUD"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{8: {'basic_transpilation': 389.1, 'transpile_left': 19.8},\n",
       " 7: {'basic_transpilation': 231.29, 'transpile_left': 16.27},\n",
       " 6: {'basic_transpilation': 169.55, 'transpile_left': 13.77},\n",
       " 5: {'basic_transpilation': 123.55, 'transpile_left': 13.11},\n",
       " 4: {'basic_transpilation': 88.25, 'transpile_left': 13.62},\n",
       " 3: {'basic_transpilation': 55.11, 'transpile_left': 12.04},\n",
       " 2: {'basic_transpilation': 25.7, 'transpile_left': 11.75}}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = {8: {'basic_transpilation': 389.1, 'transpile_left': 19.8},\n",
    "           7: {'basic_transpilation': 231.29, 'transpile_left': 16.27},\n",
    "           6: {'basic_transpilation': 169.55, 'transpile_left': 13.77},\n",
    "           5: {'basic_transpilation': 123.55, 'transpile_left': 13.11},\n",
    "           4: {'basic_transpilation': 88.25, 'transpile_left': 13.62},\n",
    "           3: {'basic_transpilation': 55.11, 'transpile_left': 12.04},\n",
    "           2: {'basic_transpilation': 25.7, 'transpile_left': 11.75}}\n",
    "\n",
    "basic_times = [results[qubit_count]['basic_transpilation'] for qubit_count in results]  # with Qiskit\n",
    "left_times = [results[qubit_count]['transpile_left'] for qubit_count in results]    # with Rivet\n",
    "\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "pP9jlIW-d65P"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Transpilation times\n",
    "\n",
    "qubit_counts = list(results.keys())\n",
    "\n",
    "plt.title(\"Transpilation time comparison\")\n",
    "plt.xlabel(\"Qubits\")\n",
    "plt.ylabel(\"Transpilation time, seconds\")\n",
    "\n",
    "plt.plot(qubit_counts, basic_times, label=\"Basic Transpilation\")   #with Qiskit\n",
    "plt.plot(qubit_counts, left_times, label=\"Transpile Left\")         #with Rivet\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zsq3SWZ2d7Xr"
   },
   "source": [
    "### 4.3. Quantum Fourier Adder Results Verification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aAIpplsQd7fX"
   },
   "source": [
    "#### 4.3.1. Run the Circuit and Collect Measurements\n",
    "We have to execute a set of transpiled quantum circuits, collect the measurement outcomes for each circuit, and store them in `counts_list` for further analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "Fy3YbMvveH4L"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████| 10/10 [00:03<00:00,  2.95 circuit/s]\n"
     ]
    }
   ],
   "source": [
    "counts_list = []\n",
    "transpiled_circuit_tracker = tqdm(transpiled_circuits, unit=' circuit', ncols=110)\n",
    "\n",
    "for transpiled_circuit in transpiled_circuit_tracker:\n",
    "    \n",
    "    job = backend.run(transpiled_circuit, shots=SHOTS_COUNT)\n",
    "    counts = job.result().get_counts()\n",
    "    counts_list.append(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S9EU8-lVeE1D"
   },
   "source": [
    "#### 4.3.2. Compare Quantum States\n",
    "To compare the quantum states and store data for the visualization we define:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "3X9ms7U-eKMF"
   },
   "outputs": [],
   "source": [
    "# Initial State Indices: Converts binary initial states into their corresponding integer indices\n",
    "initial_state_indices = [int(initial_state, 2) for initial_state in initial_states]\n",
    "\n",
    "# Top State Indices: Converts the binary representation of the top measured state into its integer index\n",
    "top_state_indices = [int(max(counts, key=counts.get), 2) for counts in counts_list]\n",
    "\n",
    "# Check that Addition works: Verifies that the addition operation on initial state indices and the specified number is correctly reflected in the top measured state indices\n",
    "assert all((top_state_index == (initial_state_index + NUMBER_TO_ADD) % states_count)\n",
    "           for initial_state_index, top_state_index in zip(initial_state_indices, top_state_indices))\n",
    "\n",
    "# Global Counts: Constructs a 2D array (global_counts) to store counts data for each experiment and state index.\n",
    "global_counts = np.array([[counts[state] if state in counts else 0\n",
    "                           for state in states]\n",
    "                          for counts in counts_list], dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zkM853vFeM85"
   },
   "source": [
    "#### 4.3.3. Visualize Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2kErWJO4eROc"
   },
   "source": [
    "Below we visualize the counts obtained from the last iteration or the experiment. The plot helps in analyzing the distribution of measurement outcomes and understanding the behavior of the quantum system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "vyTMjWmqeNId"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Last Counts\n",
    "\n",
    "last_counts = global_counts[-1]\n",
    "\n",
    "plt.title(\"Counts\")\n",
    "plt.xlabel(\"State Index\")\n",
    "plt.ylabel(\"Count\")\n",
    "plt.plot(last_counts, label=\"Initial States\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jR8tTgeWeV4w"
   },
   "source": [
    "\n",
    "Compare the initial and the measured state (affter addition operation implementation) values.\n",
    "**Expectations**: For the addition operation we set up `NUMBER_TO_ADD=2` so the different in state value should be 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "z4tiMXHKeWbg"
   },
   "outputs": [],
   "source": [
    "# Plot State Comparison\n",
    "\n",
    "plt.title(\"State Comparison\")\n",
    "plt.xlabel(\"State Index\")\n",
    "plt.ylabel(\"State Value\")\n",
    "\n",
    "plt.plot(initial_state_indices, label=\"Initial States\")\n",
    "plt.plot(top_state_indices, label=\"Measured States\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "# plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.jpg](images/Fig4_states_comparison.jpg) \n",
    "\n",
    "*Fig.4. States comparison for the initial and measured state (after addition operation implementation) values.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I97vg2NneZJN"
   },
   "source": [
    "Function `build_counts_figure` creates a 3D surface plot for visualizing state measurement results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "e_rvIz3yebX6"
   },
   "outputs": [],
   "source": [
    "def build_counts_figure(initial_states, measured_states, counts,\n",
    "                        elevation=10, initial_azimuth=230):\n",
    "\n",
    "    initial_states_grid, measured_states_grid = np.meshgrid(initial_states, measured_states)\n",
    "\n",
    "    figure, ax = plt.subplots(figsize=(5, 5),\n",
    "                              subplot_kw={\"projection\": \"3d\"})\n",
    "\n",
    "    surface = ax.plot_surface(initial_states_grid,\n",
    "                              measured_states_grid,\n",
    "                              counts.T,\n",
    "                              cmap='plasma',\n",
    "                              linewidth=30,\n",
    "                              antialiased=True)\n",
    "\n",
    "    ax.view_init(elev=elevation, azim=initial_azimuth)\n",
    "\n",
    "    ax.zaxis.set_rotate_label(False)\n",
    "\n",
    "    ax.set_xlabel('Initial State Index')\n",
    "    ax.set_ylabel('Measured State Index')\n",
    "    ax.set_zlabel('Count', rotation=90)\n",
    "\n",
    "    ax.patch.set_alpha(0)\n",
    "\n",
    "    figure.patch.set_alpha(0)\n",
    "\n",
    "    # figure.patch.set_facecolor('black')\n",
    "\n",
    "    plt.close()\n",
    "\n",
    "    return figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7C1xXNswecLP"
   },
   "source": [
    "Plot 3D surface for a subset of experiments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "VlLv8f54kEdr"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts_figure = build_counts_figure(\n",
    "    initial_states=range(EXPERIMENTS_COUNT),\n",
    "    measured_states=range(EXPERIMENTS_COUNT),\n",
    "    counts=global_counts[:,:EXPERIMENTS_COUNT],\n",
    "    elevation=30,\n",
    "    initial_azimuth=160+180\n",
    ")\n",
    "\n",
    "counts_figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AwgDIUSIelFC"
   },
   "source": [
    "## 4. Conclusions\n",
    "\n",
    "The implementation of the Quantum Fourier Adder algorithm was demonstrated, and significant speed enhancements were evident when using Rivet transpilation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5DmIJOZNWv_l"
   },
   "source": [
    "## References\n",
    "\n",
    "[1] https://en.wikipedia.org/wiki/Fourier_transform\n",
    "\n",
    "[2] https://github.com/SRI-International/QC-App-Oriented-Benchmarks/tree/master/quantum-fourier-transform\n",
    "\n",
    "[3] IBM Research Report: An Approximate Fourier Transform Useful in Quantum Factoring https://arxiv.org/pdf/quant-ph/0201067.pdf\n",
    "\n",
    "[4] https://github.com/Qiskit/textbook/blob/main/notebooks/ch-algorithms/quantum-fourier-transform.ipynb\n",
    "\n",
    "[5] Michael A. Nielsen and Isaac L. Chuang. (2011). Quantum Computation and Quantum Information: 10th Anniversary Edition (10th ed.). Cambridge University Press, New York, NY, USA.\n",
    "\n",
    "[6] Qiskit fake backends https://docs.quantum.ibm.com/api/qiskit/0.37/providers_fake_provider"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}