sympy/Basic Quantum Computer Simulator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial state, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 0, 0.7071067811865475, -0.7071067811865475, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 1, 0.49999999999999994, -0.49999999999999994, 0.49999999999999994, -0.49999999999999994, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After quantum oracle, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After Hadamard transformation on Qubit 1, 0.49999999999999983, -0.49999999999999983, 0.0, 0.0, 0.49999999999999983, -0.49999999999999983, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, 0.7071067811865472, -0.7071067811865472, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "\n",
      "Always0 is constant\n",
      "Initial state, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 0, 0.7071067811865475, -0.7071067811865475, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 1, 0.49999999999999994, -0.49999999999999994, 0.49999999999999994, -0.49999999999999994, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After quantum oracle, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737\n",
      "After Hadamard transformation on Qubit 1, -0.49999999999999983, 0.49999999999999983, 0.0, 0.0, -0.49999999999999983, 0.49999999999999983, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, -0.7071067811865472, 0.7071067811865472, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "\n",
      "Always1 is constant\n",
      "Initial state, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 0, 0.7071067811865475, -0.7071067811865475, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 1, 0.49999999999999994, -0.49999999999999994, 0.49999999999999994, -0.49999999999999994, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After quantum oracle, 0.3535533905932737, -0.3535533905932737, -0.3535533905932737, 0.3535533905932737, 0.3535533905932737, -0.3535533905932737, -0.3535533905932737, 0.3535533905932737\n",
      "After Hadamard transformation on Qubit 1, 0.0, 0.0, 0.49999999999999983, -0.49999999999999983, 0.0, 0.0, 0.49999999999999983, -0.49999999999999983\n",
      "After Hadamard transformation on Qubit 2, 0.0, 0.0, 0.7071067811865472, -0.7071067811865472, 0.0, 0.0, 0.0, 0.0\n",
      "\n",
      "isOdd is balanced\n",
      "Initial state, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 0, 0.7071067811865475, -0.7071067811865475, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 1, 0.49999999999999994, -0.49999999999999994, 0.49999999999999994, -0.49999999999999994, 0.0, 0.0, 0.0, 0.0\n",
      "After Hadamard transformation on Qubit 2, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After quantum oracle, -0.3535533905932737, 0.3535533905932737, 0.3535533905932737, -0.3535533905932737, -0.3535533905932737, 0.3535533905932737, 0.3535533905932737, -0.3535533905932737\n",
      "After Hadamard transformation on Qubit 1, 0.0, 0.0, -0.49999999999999983, 0.49999999999999983, 0.0, 0.0, -0.49999999999999983, 0.49999999999999983\n",
      "After Hadamard transformation on Qubit 2, 0.0, 0.0, -0.7071067811865472, 0.7071067811865472, 0.0, 0.0, 0.0, 0.0\n",
      "\n",
      "isEven is balanced\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python\n",
    "\n",
    "import math\n",
    "\n",
    "class QuantumComputerSimulator:\n",
    "    SQRT_2 = math.sqrt(2)\n",
    "    ONE_LOWER_TOLERANCE = 0.999\n",
    "    ONE_UPPER_TOLERANCE = 1.001\n",
    "\n",
    "    def __init__(self, numberOfQubits, initialState, verbose):\n",
    "        self.__state = [0.0 for _ in range(0, pow(2, numberOfQubits))]\n",
    "\n",
    "        # Our quantum computer definitely starts in \"initialState\".\n",
    "        self.__state[initialState] = 1.0\n",
    "        self.__verbose = verbose\n",
    "        self.log(\"Initial state\")\n",
    "\n",
    "    def applyHadamard(self, qubitIndex):\n",
    "        \"This is a constant time operation in a quantum computer.\"\n",
    "        for index in range(0, len(self.__state), 2):\n",
    "            zeroIndex = self.swapBits(0, qubitIndex, index)\n",
    "            oneIndex = self.swapBits(0, qubitIndex, index + 1)\n",
    "\n",
    "            zero = self.__state[zeroIndex]\n",
    "            one = self.__state[oneIndex]\n",
    "\n",
    "            self.__state[zeroIndex] = (zero + one) / self.SQRT_2\n",
    "            self.__state[oneIndex] = (zero - one) / self.SQRT_2\n",
    "\n",
    "        self.log(\"After Hadamard transformation on Qubit %s\" % qubitIndex)\n",
    "\n",
    "    def quantumOracle(self, function):\n",
    "        \"This is constant time on a quantum computer if function is constant time\"\n",
    "        # We go in steps of 2 as the first qubit is not an input to our function\n",
    "        for index in range(0, len(self.__state), 2):\n",
    "            result = function(index // 2)\n",
    "\n",
    "            if result == 1:\n",
    "                self.__state[index] = -self.__state[index]\n",
    "                self.__state[index + 1] = -self.__state[index + 1]\n",
    "\n",
    "        self.log(\"After quantum oracle\")\n",
    "\n",
    "    def readQubit(self, qubit):\n",
    "        mask = 1 << qubit\n",
    "        zeroProb = 0.0\n",
    "        oneProb = 0.0\n",
    "\n",
    "        for index in range(0, len(self.__state)):\n",
    "            stateProb = self.__state[index]\n",
    "            stateProb *= stateProb\n",
    "\n",
    "            if index & mask:\n",
    "                oneProb += stateProb\n",
    "            else:\n",
    "                zeroProb += stateProb\n",
    "\n",
    "        if not self.isOne(oneProb + zeroProb):\n",
    "            message = \\\n",
    "                    \"Something went wrong. \" + \\\n",
    "                    \"Total probability for a Qubit should be 1.0. \" + \\\n",
    "                    \"Could be a rounding error.\"\n",
    "            raise Exception(message)\n",
    "\n",
    "        if self.isOne(oneProb):\n",
    "            return True\n",
    "\n",
    "        if self.isOne(zeroProb):\n",
    "            return False\n",
    "\n",
    "        # In reality, observing a qubit in a superposition (not definitely 1 or 0)\n",
    "        # would result in a 1 or 0, and all entangled Qubits would need to be\n",
    "        # adjusted accordingly.\n",
    "        raise Exception(\"Qubit is not in a known state.\")\n",
    "\n",
    "    def isOne(self, number):\n",
    "        return number > self.ONE_LOWER_TOLERANCE and number < self.ONE_UPPER_TOLERANCE\n",
    "\n",
    "    @staticmethod\n",
    "    def swapBits(index1, index2, number):\n",
    "        \"Swap 2 bits in number, specified by index1 and index2\"\n",
    "        # mask for the required bits\n",
    "        mask1 = number & (1 << index1)\n",
    "        mask2 = number & (1 << index2)\n",
    "\n",
    "        # Move them to the 1st bit\n",
    "        bit1 = (mask1) >> index1\n",
    "        bit2 = (mask2) >> index2\n",
    "\n",
    "        # Zero out the bits in the number\n",
    "        number ^= (mask1 | mask2)\n",
    "\n",
    "        # Set the swapped bits\n",
    "        number |= (bit1 << index2)\n",
    "        number |= (bit2 << index1)\n",
    "\n",
    "        return number\n",
    "\n",
    "    def log(self, name):\n",
    "        if self.__verbose:\n",
    "            print(\"%s, %s\" % (name, \", \".join(map(str, self.__state))))\n",
    "\n",
    "def always0(value):\n",
    "    return 0\n",
    "\n",
    "def always1(value):\n",
    "    return 1\n",
    "\n",
    "def isOdd(value):\n",
    "    return (value & 1)\n",
    "\n",
    "def isEven(value):\n",
    "    return (value ^ 1) & 1\n",
    "\n",
    "def isConstantFunction(function, name, verbose):\n",
    "    \"This is the Deutsch-Jozsa algorithm\"\n",
    "    qubits = 3\n",
    "    computer = QuantumComputerSimulator(qubits, 1, verbose)\n",
    "\n",
    "    for qubit in range(0, qubits):\n",
    "        computer.applyHadamard(qubit)\n",
    "\n",
    "    computer.quantumOracle(function)\n",
    "\n",
    "    for qubit in range(1, qubits):\n",
    "        computer.applyHadamard(qubit)\n",
    "\n",
    "    functionChanges = False\n",
    "\n",
    "    for qubit in range(1, qubits):\n",
    "        functionChanges |= computer.readQubit(qubit)\n",
    "\n",
    "    if verbose:\n",
    "        print(\"\")\n",
    "\n",
    "    if functionChanges:\n",
    "        print(\"%s is balanced\" % name)\n",
    "    else:\n",
    "        print(\"%s is constant\" % name)\n",
    "\n",
    "    if verbose:\n",
    "        print\n",
    "\n",
    "functionList = [\n",
    "    (always0, \"Always0\"),\n",
    "    (always1, \"Always1\"),\n",
    "    (isOdd, \"isOdd\"),\n",
    "    (isEven, \"isEven\")\n",
    "]\n",
    "\n",
    "for function, name in functionList:\n",
    "    isConstantFunction(function, name, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}