Prob_Set1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#IMPORTS\n",
    "import qiskit\n",
    "import numpy as np\n",
    "from qiskit import *\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit.visualization import plot_bloch_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using the NOT gate (expressed as x in Qiskit), \n",
    "#the CNOT gate (expressed as cx in Qiskit) \n",
    "#and the Toffoli gate (expressed as ccx in Qiskit) create functions to \n",
    "#implement the XOR, AND, NAND and OR gates.\n",
    "\n",
    "#YOU CAN USE QUANTUM GATES AS CLASSICAL GATES !!!!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NOT GATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NOT(input):\n",
    "\n",
    "    q = QuantumRegister(1) # a qubit in which to encode and manipulate the input\n",
    "    c = ClassicalRegister(1) # a bit to store the output\n",
    "    qc = QuantumCircuit(q, c) # this is where the quantum program goes\n",
    "    \n",
    "    # We encode '0' as the qubit state |0⟩, and '1' as |1⟩\n",
    "    # Since the qubit is initially |0⟩, we don't need to do anything for an input of '0'\n",
    "    # For an input of '1', we do an x to rotate the |0⟩ to |1⟩\n",
    "    if input=='1':\n",
    "        qc.x( q[0] )\n",
    "        \n",
    "    # Now we've encoded the input, we can do a NOT on it using x\n",
    "    qc.x( q[0] )\n",
    "    \n",
    "    # Finally, we extract the |0⟩/|1⟩ output of the qubit and encode it in the bit c[0]\n",
    "    qc.measure( q[0], c[0] )\n",
    "    #qc.draw(output='mpl') #draw the circuit\n",
    "    # We'll run the program on a simulator\n",
    "    \n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    # Since the output will be deterministic, we can use just a single shot to get it\n",
    "    job = execute(qc,backend,shots=1)\n",
    "    output = next(iter(job.result().get_counts()))\n",
    "    \n",
    "    return output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NOT('1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NOT('0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#XOR GATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def XOR(input1,input2):\n",
    "    \n",
    "    q = QuantumRegister(2) # two qubits in which to encode and manipulate the input\n",
    "    c = ClassicalRegister(1) # a bit to store the output\n",
    "    qc = QuantumCircuit(q, c) # this is where the quantum program goes\n",
    "    \n",
    "    # YOUR QUANTUM PROGRAM GOES HERE  \n",
    "    if input1=='1':\n",
    "        qc.x( q[0] )\n",
    "        \n",
    "    if input2=='1':\n",
    "        qc.x( q[1] )\n",
    "        \n",
    "    qc.cx( q[0] , q[1] ) #cnot gate with 0th qbit as contral and 1st qbit as target\n",
    "        \n",
    "    qc.measure(q[1],c[0]) # YOU CAN CHANGE THIS IF YOU WANT TO\n",
    "    \n",
    "    # We'll run the program on a simulator\n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    # Since the output will be deterministic, we can use just a single shot to get it\n",
    "    job = execute(qc,backend,shots=1,memory=True)\n",
    "    output = job.result().get_memory()[0]\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR('0','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR('0','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR('1','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR('1','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "XOR('0','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#AND GATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def AND(input1,input2):\n",
    "    \n",
    "    q = QuantumRegister(3) # two qubits in which to encode the input, and one for the output\n",
    "    c = ClassicalRegister(1) # a bit to store the output\n",
    "    qc = QuantumCircuit(q, c) # this is where the quantum program goes\n",
    "    \n",
    "    qc.x( q[2] )\n",
    "    \n",
    "    # YOUR QUANTUM PROGRAM GOES HERE\n",
    "    if XOR(input1,input2)=='1' :\n",
    "        qc.x( q[0] )\n",
    "        \n",
    "    else :\n",
    "        if input1=='0' :\n",
    "            qc.x( q[2])\n",
    "    \n",
    "    qc.cx( q[0] , q[1] ) #cnot gate with 1st qbit as contral and 2nd qbit as target\n",
    "    qc.cx( q[1] , q[2] ) #cnot gate with 2nd qbit as contral and 3rd qbit as target\n",
    "    \n",
    "    qc.measure(q[2],c[0]) # YOU CAN CHANGE THIS IF YOU WANT TO\n",
    "    \n",
    "    # We'll run the program on a simulator\n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    # Since the output will be deterministic, we can use just a single shot to get it\n",
    "    job = execute(qc,backend,shots=1,memory=True)\n",
    "    output = job.result().get_memory()[0]\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND('0','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND('1','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND('1','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AND('0','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NAND GATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NAND(input1,input2):\n",
    "  \n",
    "    q = QuantumRegister(3) # two qubits in which to encode the input, and one for the output\n",
    "    c = ClassicalRegister(1) # a bit to store the output\n",
    "    qc = QuantumCircuit(q, c) # this is where the quantum program goes\n",
    "    \n",
    "    qc.x( q[2] )\n",
    "    \n",
    "    # YOUR QUANTUM PROGRAM GOES HERE\n",
    "    if XOR(input1,input2)=='1' :\n",
    "        qc.x( q[0] )\n",
    "        \n",
    "    else :\n",
    "        if input1=='0' :\n",
    "            qc.x( q[2])\n",
    "    \n",
    "    qc.cx( q[0] , q[1] ) #cnot gate with 1st qbit as contral and 2nd qbit as target\n",
    "    qc.cx( q[1] , q[2] ) #cnot gate with 2nd qbit as contral and 3rd qbit as target\n",
    "    \n",
    "    qc.x( q[2] )\n",
    "    \n",
    "    qc.measure(q[2],c[0]) # YOU CAN CHANGE THIS IF YOU WANT TO\n",
    "    \n",
    "    # We'll run the program on a simulator\n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    # Since the output will be deterministic, we can use just a single shot to get it\n",
    "    job = execute(qc,backend,shots=1,memory=True)\n",
    "    output = job.result().get_memory()[0]\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND('0','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND('1','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND('0','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NAND('1','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#OR GATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def OR(input1,input2):\n",
    "  \n",
    "    q = QuantumRegister(3) # two qubits in which to encode the input, and one for the output\n",
    "    c = ClassicalRegister(1) # a bit to store the output\n",
    "    qc = QuantumCircuit(q, c) # this is where the quantum program goes\n",
    "    \n",
    "    # YOUR QUANTUM PROGRAM GOES HERE\n",
    "    if XOR(input1,input2)=='1' :\n",
    "        qc.x( q[0] )\n",
    "        \n",
    "    else :\n",
    "        if input1=='1' :\n",
    "            qc.x( q[2])\n",
    "    \n",
    "    qc.cx( q[0] , q[1] ) #cnot gate with 1st qbit as contral and 2nd qbit as target\n",
    "    qc.cx( q[1] , q[2] ) #cnot gate with 2nd qbit as contral and 3rd qbit as target\n",
    "    \n",
    "    qc.measure(q[2],c[0]) # YOU CAN CHANGE THIS IF YOU WANT TO\n",
    "    \n",
    "    # We'll run the program on a simulator\n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    # Since the output will be deterministic, we can use just a single shot to get it\n",
    "    job = execute(qc,backend,shots=1,memory=True)\n",
    "    output = job.result().get_memory()[0]\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR('0','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR('0','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR('1','0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OR('1','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The following code runs the functions above for all possible inputs, so that you can check whether they work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Results for the NOT gate\n",
      "    Input 0 gives output 1\n",
      "    Input 1 gives output 0\n",
      "\n",
      "Results for the XOR gate\n",
      "    Inputs 0 0 give output 0\n",
      "    Inputs 0 1 give output 1\n",
      "    Inputs 1 0 give output 1\n",
      "    Inputs 1 1 give output 0\n",
      "\n",
      "Results for the AND gate\n",
      "    Inputs 0 0 give output 0\n",
      "    Inputs 0 1 give output 0\n",
      "    Inputs 1 0 give output 0\n",
      "    Inputs 1 1 give output 1\n",
      "\n",
      "Results for the NAND gate\n",
      "    Inputs 0 0 give output 1\n",
      "    Inputs 0 1 give output 1\n",
      "    Inputs 1 0 give output 1\n",
      "    Inputs 1 1 give output 0\n",
      "\n",
      "Results for the OR gate\n",
      "    Inputs 0 0 give output 0\n",
      "    Inputs 0 1 give output 1\n",
      "    Inputs 1 0 give output 1\n",
      "    Inputs 1 1 give output 1\n"
     ]
    }
   ],
   "source": [
    "print('\\nResults for the NOT gate')\n",
    "for input in ['0','1']:\n",
    "    print('    Input',input,'gives output',NOT(input))\n",
    "    \n",
    "print('\\nResults for the XOR gate')\n",
    "for input1 in ['0','1']:\n",
    "    for input2 in ['0','1']:\n",
    "        print('    Inputs',input1,input2,'give output',XOR(input1,input2))\n",
    "\n",
    "print('\\nResults for the AND gate')\n",
    "for input1 in ['0','1']:\n",
    "    for input2 in ['0','1']:\n",
    "        print('    Inputs',input1,input2,'give output',AND(input1,input2))\n",
    "\n",
    "print('\\nResults for the NAND gate')\n",
    "for input1 in ['0','1']:\n",
    "    for input2 in ['0','1']:\n",
    "        print('    Inputs',input1,input2,'give output',NAND(input1,input2))\n",
    "\n",
    "print('\\nResults for the OR gate')\n",
    "for input1 in ['0','1']:\n",
    "    for input2 in ['0','1']:\n",
    "        print('    Inputs',input1,input2,'give output',OR(input1,input2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}