qoqo/4_Half_adder_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2021-2022 HQS Quantum Simulations GmbH. All Rights Reserved.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n",
    "in compliance with the License. You may obtain a copy of the License at\n",
    "\n",
    "http://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software distributed under the\n",
    "License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n",
    "express or implied. See the License for the specific language governing permissions and\n",
    "limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: Half Adder\n",
    "In this example we write a quantum algorithm to perform an add operation between two qubits and store the result in two qubits that act as output register.\n",
    "\n",
    "The truth table of the circuit is\n",
    "\n",
    "| in q1 | in q2 | out q4 | out q3 | out  (integer) |\n",
    "|-------|-------|--------|--------|----------------|\n",
    "| 0     | 0     | 0      | 0      | 0              |\n",
    "| 0     | 1     | 0      | 1      | 1              |\n",
    "| 1     | 0     | 0      | 1      | 1              |\n",
    "| 1     | 1     | 1      | 0      | 2              |\n",
    "\n",
    "Please note that for simplicity we implement a half adder that picks up an additional phase. This circuit only works as a half-adder if the result is measured immediately. A half-adder implementation without an extra phase would require a decomposition of the Toffoli gate which requires more than three CNOT gates.\n",
    "\n",
    "The circuit that we will code to implement a half adder is as follows:\n",
    "\n",
    "![half adder](half_adder.png)\n",
    "\n",
    "The two `X` operations at the beginning are used to generate the input, in this case both input qubits are set to `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A small helper routine for nice output\n",
    "def get_binary(x: int, size: int) -> str:\n",
    "    \"\"\"Return a string representation of int x with size positions.\"\"\"\n",
    "    return format(x, 'b').zfill(size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We import required classes and modules from qoqo. Circuit is the main class to represent quantum circuits. The operations module contains one- and two-qubit operations such as Hadamard or CNOT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qoqo import Circuit\n",
    "from qoqo import operations as ops\n",
    "from pprint import pprint as pp\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a method to generate the main block of the half-adder circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def half_adder_main() -> Circuit():\n",
    "    half_adder = Circuit(4)\n",
    "    ####################\n",
    "    # Least relevant bit\n",
    "    half_adder += ops.CNOT(control=0, target=2)\n",
    "    half_adder += ops.CNOT(control=1, target=2)\n",
    "    ###################\n",
    "    # Most relevant bit\n",
    "    # Controlled H\n",
    "    half_adder += ops.RotateY(3, math.pi / 4)\n",
    "    half_adder += ops.CNOT(0, 3)\n",
    "    half_adder += ops.RotateY(3, -math.pi / 4)\n",
    "    # Controlled Z\n",
    "    half_adder += ops.Hadamard(3)\n",
    "    half_adder += ops.CNOT(1, 3)\n",
    "    half_adder += ops.Hadamard(3)\n",
    "    # Controlled H\n",
    "    half_adder += ops.RotateY(3, math.pi / 4)\n",
    "    half_adder += ops.CNOT(0, 3)\n",
    "    half_adder += ops.RotateY(3, -math.pi / 4)\n",
    "    return half_adder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add everything together. We add a complex classical register to store the state vector of the qubits after our calculation. Other types of registers available in qoqo are `DefinitionBit` for bit registers used to store actual measurement results of a quantum computer and `DefinitionFloat` to store real valued results.\n",
    "\n",
    "We use the `GetStateVector` Pragma operation. A Pragma operation is information for the compiler / qoqo only and will not be sent to the actual quantum computer. We will encounter other important Pragmas later on. The `GetStateVector` Pragma operation obtains the state vector of the qubits and stores it in the defined output register ('ro'). It accepts an additional measurement circuit that would be added to the circuit before measuring. The state vector can only be obtained in simulations on conventional computers, never from the real device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "half_adder = Circuit(4)\n",
    "half_adder += ops.DefinitionComplex('ro', 2**4, is_output=True)\n",
    "# Init\n",
    "half_adder += ops.PauliX(0)\n",
    "half_adder += ops.PauliX(1)\n",
    "#main\n",
    "half_adder += half_adder_main()\n",
    "# Measure\n",
    "half_adder += ops.PragmaGetStateVector('ro', Circuit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(half_adder)\n",
    "# from qoqo_qasm import qasm_call_circuit\n",
    "# qasm_call_circuit(half_adder_main())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We simulate the half adder using `qoqo_quest`. Running the circuit in the backend returns a tuple with entries for all registers of the three different types.\n",
    "\n",
    "We print the complex coefficients (amplitudes) of the quantum state. The input qubits are the two bits on the right side (as they are qubits 0 and 1) while the output is stored in the most relevant bits (the two right bits). As expected, the state `|1011>` is populated while all other states are empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qoqo_quest import Backend\n",
    "backend = Backend(4)\n",
    "(\n",
    "    res_bit_registers,\n",
    "    res_float_registers,\n",
    "    res_complex_registers\n",
    ") = backend.run_circuit(half_adder)\n",
    "pp({\n",
    "    get_binary(x, 4): value.real for x, value in enumerate(\n",
    "        res_complex_registers['ro'][0]\n",
    "    )\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating an experiment\n",
    "\n",
    "How would the result that we would get from a real quantum computer look? Let's try it out!\n",
    "\n",
    "We define a number of measurements, *i.e.*, repetitions and measurements of the circuit and add a bit register to store the measured values for each run.\n",
    "\n",
    "We add `MeasureQubit` operations for the two output qubits.\n",
    "To make this more interesting we initialize the input qubits in a superposition of all possible states using Hadamard gates `H`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_measurements = 1000\n",
    "half_adder = Circuit(4)\n",
    "half_adder += ops.DefinitionBit('ro', 2, is_output=True)\n",
    "# Input\n",
    "half_adder += ops.Hadamard(0)\n",
    "half_adder += ops.Hadamard(1)\n",
    "# Main\n",
    "half_adder += half_adder_main()\n",
    "# Measure\n",
    "half_adder += ops.MeasureQubit(2, 'ro', readout_index=0)\n",
    "half_adder += ops.MeasureQubit(3, 'ro', readout_index=1)\n",
    "half_adder += ops.PragmaSetNumberOfMeasurements(number_measurements, 'ro')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(\n",
    "    res_bit_registers,\n",
    "    res_float_registers,\n",
    "    res_complex_registers\n",
    ") = backend.run_circuit(half_adder)\n",
    "# transform measured bitstring into integers\n",
    "results = [int(f\"{int(x[1])}{int(x[0])}\", base=2) for x in res_bit_registers['ro']]\n",
    "# pp(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We plot the histogram of the measured bitstring interpreted as integer. We expect 25% 0, 50% 1 and 25% 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.hist(results, bins=[-0.5, 0.5, 1.5, 2.5])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('base')",
   "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a1ba31c400d137d76a70fc2e1974f61660e195f0d443a61c8b897cf0b0e57695"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}