SectionA_QC_Hackathon.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Bb4QIJiuOksc"
   },
   "source": [
    "# Welcome to <font color=\"red\">QC Hackathon 2021</font>!\n",
    "\n",
    "Quantum Coputation is an up and coming field that uses quantum gates to perform operations which exploit properties of a quantum state like superposition, and entanglement to perform computations. The aim is to solve computation problems in executable time that might not be solvable using its classical analogue. In this hackathon, we will be introducing you to challenges of different difficulty levels. \n",
    "\n",
    "A good introduction to all of these concepts can be found in the [qiskit textbook](https://qiskit.org/textbook/preface.html). We will be using qiskit in this hackathon. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tULi4LXO83vD"
   },
   "source": [
    "# Challenge Tier - I\n",
    "For this first set of challenges, we encourage you to read [Section 1.4](https://qiskit.org/textbook/ch-states/single-qubit-gates.html) and [Section 2.2](https://qiskit.org/textbook/ch-gates/multiple-qubits-entangled-states.html) to get familiar with the basics of quantum computing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#before we start, run this cell to install qiskit\n",
    "!pip install qiskit\n",
    "!pip install pylatexenc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oqF515b7wIGi"
   },
   "source": [
    "## Task 1 \n",
    "$$\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}$$\n",
    "$$\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$$\n",
    "\n",
    "An $H$ gate, or a Hadamard gate, is a single qubit gate which performs the following operations:\n",
    "<center>\n",
    "$\\begin{align}\n",
    "  H\\ket{0} &= \\dfrac{\\ket{0}+\\ket{1}}{\\sqrt{2}}\\\\\n",
    "  H\\ket{1} &= \\dfrac{\\ket{0}-\\ket{1}}{\\sqrt{2}}\n",
    "\\end{align}$ \n",
    "</center>\n",
    "\n",
    "A $Z$ gate, similarly, performs the following operations:\n",
    "<center>\n",
    "$\\begin{align}\n",
    "  Z\\ket{0} &= \\ket{0}\\\\\n",
    "  Z\\ket{1} &= -\\ket{1}\n",
    "\\end{align}$ \n",
    "</center>\n",
    "\n",
    "In this challenge, you will be given a single bit unitary operation that can either be an $H$ gate or a $Z$ gate. You can apply the unitary operation **at most twice**. Using what you learnt from [Section 1.4](https://qiskit.org/textbook/ch-states/single-qubit-gates.html), distinguish whether the given operation is an H gate or a Z gate.\n",
    "\n",
    "**Output:** 0 if it is the $Z$ gate, 1 if it is the $H$ gate.",
    "\n",
    "UPDATE: You are allowed to use any other gates any number of times. Only the unitary operation has the given condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Jgyk9pmE023o"
   },
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "\n",
    "def A1_solve(Unitary, qc):\n",
    "  ##########################################\n",
    "  #enter your code here\n",
    "  #To apply the unitary to the qubit, use syntax: Unitary(0)\n",
    "\n",
    "\n",
    "  #Expected Output: {'0': 1024} if Z gate; and\n",
    "  #                 {'1': 1024} if H gate\n",
    "  \n",
    "  ###########################################\n",
    "  qc.measure(0,0)\n",
    "  print(qc.draw())\n",
    "\n",
    "  backend = Aer.get_backend('qasm_simulator')\n",
    "  job = execute(qc, backend)\n",
    "  counts = job.result().get_counts()\n",
    "\n",
    "  return counts\n",
    "\n",
    "\n",
    "\n",
    "import random\n",
    "qr = QuantumRegister(1)\n",
    "cr = ClassicalRegister(1)\n",
    "A1_qc = QuantumCircuit(qr, cr)\n",
    "if __name__ == \"__main__\":\n",
    "  if random.uniform(0,1) < 0.5:\n",
    "    Unitary = A1_qc.z\n",
    "  else:\n",
    "    Unitary = A1_qc.h\n",
    "\n",
    "  _output = A1_solve(Unitary, A1_qc)\n",
    "  print(_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6VHVW51IUnjy"
   },
   "source": [
    "## Task 2\n",
    "Any quantum state can be written in the form of a superposition of the $\\ket{0}$ and $\\ket{1}$ states in the dirac notation. So any single qubit quantum state, $\\ket{\\psi}$, can be written as:\n",
    "$\\begin{equation}\\ket{\\psi} = \\alpha \\ket{0} + \\beta \\ket{1} \\end{equation}$ where the squares of the coefficients of $\\ket{0}$ and $\\ket{1}$ are equal to the respective probability of the output on measuring $\\ket{\\psi}$. <br>\n",
    "Similarly, two qubit states can be described by: $\\displaystyle \\begin{equation}\\ket{\\psi} = \\sum_{j, k\\in\\{0,1\\}} \\alpha_{jk}\\ket{j k} \\end{equation}$\n",
    "\n",
    "Using simple quantum gates like the ones you have learnt in [Section 1.4](https://qiskit.org/textbook/ch-states/single-qubit-gates.html) and [Section 2.2](https://qiskit.org/textbook/ch-gates/multiple-qubits-entangled-states.html), prepare the superposition state described by:\n",
    "<center>$\\begin{align} \\ket{\\psi} = \\dfrac{1}{2}\\ket{01} + \\dfrac{1}{2}\\ket{10} + \\dfrac{1}{\\sqrt{2}}\\ket{00} \\end{align}$ </center>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c3toK3RhD6ta"
   },
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "\n",
    "def A2_solve():\n",
    "  \n",
    "  #enter your code here, specify the qubits in QuantumCircuit\n",
    "  qc = QuantumCircuit( , 2)\n",
    "\n",
    "\n",
    "  return\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "  A2_solve()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ap8WCoO25ST8"
   },
   "source": [
    "## Task 3 \n",
    "\n",
    "A full subtractor is a combinational circuit that performs subtraction of two bits in classical computation. A thorough explanation and implementation of the circuit can be found here: [Full Subtractor Circuit in digital logic](www.geeksforgeeks.org/full-subtractor-in-digital-logic/). Throughout this challenge you may have realised that the quantum gates are very similar to classical gates, and the elementary quantum gates can be used in place of their classical analogues in a quantum circuit. \n",
    "\n",
    "Your task is to implement a full subtractor circuit using only quantum gates.  You can take help from the resource mentioned above, and try to replace the classical gates with their quantum analogues. In more precise terms, you must reproduce the results of the truth table that can be found in the link above.\n",
    "\n",
    "**Input:** Three values: $A$, $B$, $B_{in}$; that correspond to the truth table.\n",
    "\n",
    "**Output:** Two values: $D$, $B_{out}$ (You must measure two qubits in your circuit)\n",
    "\n",
    "There is a bonus point for using the minimum number of qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZHkxLR6hTuRW"
   },
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "\n",
    "def A3_solve(inputBits):\n",
    "  no_of_qubits_used =                          #Enter the number of qubits you require\n",
    "  qc = QuantumCircuit(no_of_qubits_used, 2)\n",
    "  for i in range(0, len(inputBits)):\n",
    "    if inputBits[i] == 1:\n",
    "      qc.x(i)\n",
    "  #Enter code from here:\n",
    "\n",
    "  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "  ################### Tests ##################################### \n",
    "  print(qc.draw())\n",
    "  backend = Aer.get_backend('qasm_simulator')\n",
    "  job = execute(qc, backend)\n",
    "  counts = job.result().get_counts()\n",
    "  outputList = list(counts.keys())\n",
    "  if len(outputList) != 1 or len(outputList[0][0]) > 2:\n",
    "    print('Error: There are too many outputs.')\n",
    "    return\n",
    "  output = outputList[0]\n",
    "  if len(output) != 2:\n",
    "    print('Error: There are too few outputs. Please make sure you are *measuring* the appropriate qubits in your circuit. Use qc.measure() method to measure the qubits.')\n",
    "    return\n",
    "  \n",
    "  return output[0], output[1]\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "  A = 1\n",
    "  B = 0\n",
    "  B_in = 1\n",
    "  _D, _Bout = A3_solve([A, B, B_in])\n",
    "  print(_D, _Bout)\n",
    "  #You need to check whether these are consistent with the truth table yourself. UPDATE: You are also free to change the sequence of the output qubits according to your usecase (i.e., you are allowed to edit the code to make it 'output[1], output[0]' if you need.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional information\n",
    "\n",
    "**Created by:** Yashee Sinha"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "SectionA_QC_Hackathon.ipynb",
   "provenance": []
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}