H(ello world) in 5 languages.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pylab as pl\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "In this notebook we'll run the same quantum circuit $H |0>$ using 5 different quantum programming packages:\n",
    "\n",
    "- [Project Q](#Project-Q)\n",
    "- [Qiskit](#Qiskit)\n",
    "- [Quil](#Quil)\n",
    "- [Cirq](#Cirq)\n",
    "- [Q#](#Q$\\#$)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $H |0>$ on the Bloch sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qutip import Bloch, basis\n",
    "from qutip import snot  # Hadamard gate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snot() * basis(2, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = pl.figure(figsize=(6, 6))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "b = Bloch(fig=fig, axes=ax)\n",
    "state = snot() * basis(2, 0)\n",
    "b.add_states(state)\n",
    "b.render(fig=fig, axes=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from projectq import MainEngine\n",
    "from projectq.ops import H, Measure\n",
    "\n",
    "eng = MainEngine()\n",
    "qubit = eng.allocate_qubit()\n",
    "\n",
    "H | qubit\n",
    "Measure | qubit\n",
    "\n",
    "eng.flush()\n",
    "print(\"Measured {}\".format(int(qubit)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qiskit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import BasicAer\n",
    "from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit\n",
    "from qiskit import execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up Quantum Register and Classical Register for 1 qubit\n",
    "q = QuantumRegister(1)\n",
    "c = ClassicalRegister(1)\n",
    "qc = QuantumCircuit(q, c)\n",
    "qc.h(q)\n",
    "qc.measure(q, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "job = execute(qc, backend=BasicAer.get_backend('qasm_simulator'), shots=1000)\n",
    "result = job.result()\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result.get_counts(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get quantum wavefunction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "job = execute(qc, backend=BasicAer.get_backend('statevector_simulator'))\n",
    "result = job.result()\n",
    "state = result.get_statevector()\n",
    "state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.api import QVMConnection\n",
    "from pyquil.quil import Program, Declare\n",
    "from pyquil.gates import X, MEASURE, RX, H\n",
    "import subprocess\n",
    "\n",
    "# Start the Lisp server in a subprocess\n",
    "qvm_server = subprocess.Popen([\"/src/qvm/qvm\", \"-S\"])\n",
    "\n",
    "# Connect to the QVM\n",
    "qvm = QVMConnection()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "program = Program()\n",
    "ro = program.declare('ro', 'BIT')\n",
    "program += H(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "result = qvm.run(program + MEASURE(0, ro[0]), trials=1000)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(result).T[0].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wf = qvm.wavefunction(program)\n",
    "wf.amplitudes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stop the Lisp server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qvm_server.terminate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cirq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cirq\n",
    "simulator = cirq.Simulator()\n",
    "\n",
    "qubit = cirq.GridQubit(0, 0)\n",
    "circuit = cirq.Circuit.from_ops(\n",
    "    cirq.H(qubit),\n",
    "    cirq.measure(qubit, key='m')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = simulator.run(circuit, repetitions=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result.measurements[\"m\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(result.measurements[\"m\"]).T.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q$\\#$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure to change the kernel to Q# before running this part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "open Microsoft.Quantum.Extensions.Diagnostics; // import the DumpMachine function\n",
    "\n",
    "operation Hadamard(count: Int) : ( Result[], Int )\n",
    "    {\n",
    "        mutable r = Zero;\n",
    "        mutable numOnes = 0;\n",
    "        mutable results = new Result[0];\n",
    "\n",
    "        using (qubits = Qubit[1]) {\n",
    "            for (test in 1..count)\n",
    "            {\n",
    "                H(qubits[0]);\n",
    "\n",
    "                if (test == 1)\n",
    "                {\n",
    "                    DumpMachine(); // Show the current waveform\n",
    "                }\n",
    "\n",
    "                set r = M (qubits[0]);\n",
    "\n",
    "                // Add to the results\n",
    "                set results = results + [r];\n",
    "\n",
    "                // Count the number of ones we saw:\n",
    "                if (r == One)\n",
    "                {\n",
    "                    set numOnes = numOnes + 1;\n",
    "                }\n",
    "\n",
    "                ResetAll(qubits);\n",
    "            }\n",
    "        }\n",
    "\n",
    "        return (results, numOnes);\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operation HadamardRuns() : ( Result[], Int ) {\n",
    "    let count = 10;\n",
    "    return Hadamard(count);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%simulate HadamardRuns"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}