Basics - Amazon Braket.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Before we start getting into Amazon Braket\n",
    " \n",
    "#### We have to understand the gates supported by amazon local simulator as it varies by different providers\n",
    "#### But standard qauntum quantum gates remains same across different providers\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CY', 'CZ', 'H', 'I', 'ISwap', 'PSwap', 'PhaseShift', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "from braket.circuits import Gate\n",
    "\n",
    "# print all available gates in Amazon Braket\n",
    "gate_set = [attr for attr in dir(Gate) if attr[0] in string.ascii_uppercase]\n",
    "print(gate_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Demo of Superposition - Hadamard gate\n",
    "\n",
    "A hadamard gate is used to superpositioning of the qubit - converting a classical state to quantum state \n",
    "0 to |0> |1> state with amplitude for each state\n",
    "\n",
    "With this example - one can see the entanglement and how quantum gates can be used as classic gates \n",
    "demonstration of X gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|Result Types|\n",
      "                     \n",
      "q0 : -H-Probability--\n",
      "        |            \n",
      "q1 : -X-Probability--\n",
      "\n",
      "T  : |0|Result Types|\n",
      "Results:\n",
      "[0, 1]\n",
      "Counter({'01': 529, '11': 471})\n",
      "{'01': 0.529, '11': 0.471}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from braket.circuits import Circuit\n",
    "from braket.devices import LocalSimulator\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#Building Circuit\n",
    "circ=Circuit()\n",
    "circ.h(0)\n",
    "circ.x(1)\n",
    "\n",
    "#circ.x(0).x(0)\n",
    "\n",
    "circ.probability()\n",
    "print(circ)\n",
    "\n",
    "#Intializing Device to run the circuit and extract results\n",
    "device = LocalSimulator()\n",
    "task=device.run(circ,shots=1000) #pass circuit and number of iterations\n",
    "results=task.result()\n",
    "\n",
    "# get measurement results\n",
    "measurements = results.measurements\n",
    "measured_qubits = results.measured_qubits\n",
    "measurement_counts = results.measurement_counts\n",
    "measurement_probabilities = results.measurement_probabilities\n",
    "\n",
    "print('Results:')\n",
    "print(measured_qubits)\n",
    "print(measurement_counts)\n",
    "print(measurement_probabilities)\n",
    "  \n",
    "probs_values = results.values[0]\n",
    "# bitstrings\n",
    "format_bitstring = '{0:0' + str(2) + 'b}'\n",
    "bitstring_keys = [format_bitstring.format(ii) for ii in range(2**2)]\n",
    "    \n",
    "# plot probabalities\n",
    "plt.bar(bitstring_keys, probs_values);\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('probability');\n",
    "plt.xticks(rotation=90);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building quantum circuits incremental in three ways in Braket\n",
    "* Using . and append gates and operations\n",
    "* Using keyword instruction\n",
    "* Using register keyword - to register a method which returns circuit under Circuit class - Increases modularity\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|2|\n",
      "            \n",
      "q0 : -X-X-H-\n",
      "\n",
      "T  : |0|1|2|\n",
      "Amplitude(state=['0', '1'])\n",
      "{'0': (0.7071067811865475+0j), '1': (0.7071067811865475+0j)}\n"
     ]
    }
   ],
   "source": [
    "#Building incremental circuit using . \n",
    "from braket.circuits import Circuit\n",
    "\n",
    "circ=Circuit()\n",
    "\n",
    "circ.x(0).x(0).h(0)\n",
    "\n",
    "circ.amplitude(state=[\"0\",\"1\"])\n",
    "print(circ)\n",
    "\n",
    "print(circ.result_types[0])\n",
    "\n",
    "task=device.run(circ,shots=0)\n",
    "results=task.result()\n",
    "\n",
    "print(results.values[0])\n",
    "\n",
    "#Amplitude and State vector can be observed only when shots=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|\n",
      "          \n",
      "q0 : -X-H-\n",
      "\n",
      "T  : |0|1|\n"
     ]
    }
   ],
   "source": [
    "#Building incremental cicuit using instruction keyword\n",
    "\n",
    "from braket.circuits import Gate,Instruction\n",
    "\n",
    "circ=Circuit()\n",
    "\n",
    "instr1=Instruction(Gate.X(),0)\n",
    "instr2=Instruction(Gate.H(),0)\n",
    "\n",
    "circ.add_instruction(instr1)\n",
    "circ.add_instruction(instr2)\n",
    "\n",
    "print(circ)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before:\n",
      " \n",
      "After:\n",
      " T  : |0|1|\n",
      "          \n",
      "q0 : -X-H-\n",
      "          \n",
      "q1 : -X-H-\n",
      "\n",
      "T  : |0|1|\n"
     ]
    }
   ],
   "source": [
    "#Building using subroutine\n",
    "from braket.circuits import circuit\n",
    "\n",
    "@circuit.subroutine(register=True)\n",
    "def superimposed_x(target):\n",
    "    \n",
    "    circ=Circuit()\n",
    "    \n",
    "    circ.x(target)\n",
    "    circ.h(target)\n",
    "    \n",
    "    return circ\n",
    "\n",
    "#Building Circuit using subroutine\n",
    "circ=Circuit()\n",
    "print('Before:\\n',circ)\n",
    "    \n",
    "circ.superimposed_x(1)\n",
    "circ.superimposed_x(0)\n",
    "    \n",
    "print('After:\\n',circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Demonstrations of some of the gates \n",
    "###### Gates are two types-  single qubit (applied only on one qubit) and multi qubits(applied on more than one qubit)\n",
    "\n",
    "* CNOT - Controlled NOT gate \n",
    "* CCNOT - Toffoli gate (Universal Reversible Gates)\n",
    "* Swap gates - Swapping values between two qubits \n",
    "* Phase shift gates - Rx,Ry,Rz - rotation by theta radians\n",
    "\n",
    "\n",
    "###### Self defined Unitary gates can also be used as shown below\n",
    "import numpy as np <br>\n",
    "my_unitary = np.array([[0, 1],[1, 0]])  <br>\n",
    "circ.unitary(matrix=my_unitary, targets=[0]) <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|Result Types|\n",
      "                       \n",
      "q0 : ---X-Probability--\n",
      "        | |            \n",
      "q1 : -X-C-Probability--\n",
      "\n",
      "T  : |0|1|Result Types|\n",
      "{'11': 1.0}\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEJCAYAAACZjSCSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAASdElEQVR4nO3de7SldV3H8fdHCK+I0oxmDOOgjshkIniCTEtMLbAWuJaojJVWLqeWkYtllnRZaFQr1MwrmaOSeIOQljrpKKtloGGhM8QdFjoRyJESLBRcaoh++2M/A5s9+5yz5/Ls7Znf+7XWWee5/Pazv/P8MZ/z+/2eS6oKSVK77jfrAiRJs2UQSFLjDAJJapxBIEmNMwgkqXEGgSQ1bt9ZF7CzVqxYUWvWrJl1GZK0rFx66aVfr6qV4/YtuyBYs2YNW7dunXUZkrSsJLlpoX0ODUlS4wwCSWqcQSBJjTMIJKlxBoEkNa63IEhyVpJbk1y9wP4keVuSbUmuTHJkX7VIkhbWZ4/gfcCxi+w/Dljb/WwA3tljLZKkBfQWBFX1OeB/F2lyAvD+GrgEeFiSR/VVjyRpvFneUHYQcPPQ+ny37b9GGybZwKDXwOrVq6dSnKQfPmtO/eSsS5ipG8/4pV6OO8vJ4ozZNvZ1aVW1sarmqmpu5cqxd0hLknbRLINgHjh4aH0VcMuMapGkZs0yCDYBL+muHvpp4JtVtcOwkCSpX73NESQ5BzgGWJFkHngt8CMAVfW3wGbgucA24NvAb/RViyRpYb0FQVWtX2J/Ab/T1/dLkibjncWS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxvUaBEmOTXJ9km1JTh2zf3WSC5NcluTKJM/tsx5J0o56C4Ik+wBnAscB64D1SdaNNPsT4LyqOgI4CfibvuqRJI3XZ4/gKGBbVd1QVXcB5wInjLQp4KHd8gHALT3WI0kao88gOAi4eWh9vts27HXAryaZBzYDvzvuQEk2JNmaZOttt93WR62S1Kw+gyBjttXI+nrgfVW1Cngu8IEkO9RUVRuraq6q5lauXNlDqZLUrj6DYB44eGh9FTsO/bwMOA+gqv4NeACwoseaJEkj+gyCLcDaJIck2Y/BZPCmkTZfAZ4FkOQwBkHg2I8kTVFvQVBVdwMnAxcA1zG4OuiaJKcnOb5r9nvAy5NcAZwD/HpVjQ4fSZJ6tG+fB6+qzQwmgYe3nTa0fC3wtD5rkCQtzjuLJalxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGTRQESfbpuxBJ0mxM2iPYluSNSdb1Wo0kaeomDYInAV8C3pPkkiQbkjy0x7okSVMyURBU1Z1V9e6q+hngD4DXAv+V5Owkj+u1QklSryaeI0hyfJKPAm8F3gQ8BvhHYHOP9UmSejbp0NCXgROAN1bVEVX111X1tao6H/j0Qh9KcmyS65NsS3LqAm1emOTaJNck+fDO/xMkSbtj3wnbvaSqLh7ekORpVfX5qnrluA90VxqdCTwHmAe2JNlUVdcOtVkL/CHwtKq6PckjdulfIUnaZZP2CN42Ztvbl/jMUcC2qrqhqu4CzmXQqxj2cuDMqrodoKpunbAeSdIesmiPIMlTgZ8BViZ51dCuhwJL3VtwEHDz0Po8cPRIm8d33/P57nivq6oFh5okSXveUkND+wEP6drtP7T9DuDEJT6bMdtqzPevBY4BVgH/kuSJVfWN+xwo2QBsAFi9evUSXytJ2hmLBkFVfRb4bJL3VdVNO3nseeDgofVVwC1j2lxSVd8D/jPJ9QyCYctIHRuBjQBzc3OjYSJJ2g1LDQ29papOAd6RZIf/gKvq+EU+vgVYm+QQ4KvAScCLR9p8DFgPvC/JCgZDRTfsRP2SpN201NDQB7rff7WzB66qu5OcDFzAYPz/rKq6JsnpwNaq2tTt+4Uk1wLfB36/qv5nZ79LkrTrlhoaurT7/dldOXhVbWbkhrOqOm1ouYBXdT+SpBlYamjoKnac4L1HVT1pj1ckSZqqpYaGfnkqVUiSZmapoaGdvVJIkrTMLHpncZKLu993Jrlj9Pd0SpQk9WmpHsHTu9/7L9ZOkrR8TfrQOZIcCTydweTxxVV1WW9VSZKmZtL3EZwGnA38KLCCwQ1gf9JnYZKk6Zi0R7AeOKKqvguQ5Azg34E/76swSdJ0TPoY6huBBwyt3x/4jz1ejSRp6pa6oeztDOYE/g+4Jsk/devPAS5e7LOSpOVhqaGhrd3vS4GPDm2/qJdqJElTt9Tlo2dPqxBJ0mxMNFncvVv4L4F1DM0VVNVjeqpLkjQlk04W/x3wTuBu4JnA+7n3EdWSpGVs0iB4YFV9BkhV3VRVrwN+vr+yJEnTMul9BN9Ncj/gy93LZr4KPKK/siRJ0zJpj+AU4EHAK4GnAL8GvLSvoiRJ0zNRj6CqtgB0vYJXVtWdvVYlSZqaSZ81NNe9rexK4KokVyR5Sr+lSZKmYdI5grOAV1TVvwAkeTqDK4l8VaUkLXOTzhHcuT0EAKrqYsDhIUnaCyz1rKEju8UvJnkXcA6DZw29CB8zIUl7haWGht40sv7aoeXaw7VIkmZgqWcNPXNahUiSZmPSq4YOSPLXSbZ2P29KckDfxUmS+jfpZPFZDCaHX9j93MHgqiFJ0jI36eWjj62q5w+t/2mSy/soSJI0XZP2CL7T3TsAQJKnAd/ppyRJ0jRN2iP4beD9Q/MCt+OzhiRpr7BkEHTPFzq0qg5P8lCAqrqj98okSVOx5NBQVf0AOLlbvsMQkKS9y6RzBP+U5NVJDk5y4PafXiuTJE3FpHMEv8ngTuJXjGz3ncWStMxN2iNYB5wJXAFcDrwd+ImlPpTk2CTXJ9mW5NRF2p2YpJLMTViPJGkPmTQIzgYOA97GIAQO67YtKMk+DMLjOAZBsj7JujHt9mfw5rMvTF62JGlPmXRo6NCqOnxo/cIkVyzxmaOAbVV1A0CSc4ETgGtH2v0Z8Abg1RPWIknagybtEVyW5Ke3ryQ5Gvj8Ep85CLh5aH2+23aPJEcAB1fVJxY7UJIN259zdNttt01YsiRpEpMGwdHAvya5McmNwL8Bz0hyVZIrF/hMxmy759HV3f0JbwZ+b6kvr6qNVTVXVXMrV66csGRJ0iQmHRo6dheOPQ8cPLS+CrhlaH1/4InARUkAfgzYlOT4qtq6C98nSdoFEwVBVd20C8feAqxNcgjwVeAk4MVDx/wmsGL7epKLgFcbApI0XZMODe20qrqbwR3JFwDXAedV1TVJTk9yfF/fK0naOZMODe2SqtoMbB7ZdtoCbY/psxZJ0ni99QgkScuDQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuN6DYIkxya5Psm2JKeO2f+qJNcmuTLJZ5I8us96JEk76i0IkuwDnAkcB6wD1idZN9LsMmCuqp4EnA+8oa96JEnj9dkjOArYVlU3VNVdwLnACcMNqurCqvp2t3oJsKrHeiRJY/QZBAcBNw+tz3fbFvIy4FM91iNJGmPfHo+dMdtqbMPkV4E54BkL7N8AbABYvXr1nqpPkkS/PYJ54OCh9VXALaONkjwb+GPg+Kr6v3EHqqqNVTVXVXMrV67spVhJalWfQbAFWJvkkCT7AScBm4YbJDkCeBeDELi1x1okSQvoLQiq6m7gZOAC4DrgvKq6JsnpSY7vmr0ReAjwkSSXJ9m0wOEkST3pc46AqtoMbB7ZdtrQ8rP7/H5J0tK8s1iSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhrXaxAkOTbJ9Um2JTl1zP77J/n7bv8Xkqzpsx5J0o56C4Ik+wBnAscB64D1SdaNNHsZcHtVPQ54M/D6vuqRJI3XZ4/gKGBbVd1QVXcB5wInjLQ5ATi7Wz4feFaS9FiTJGnEvj0e+yDg5qH1eeDohdpU1d1Jvgn8KPD14UZJNgAbutVvJbm+l4r7t4KRf5t2iudv93kOd89Mz192b8zk0Qvt6DMIxv1lX7vQhqraCGzcE0XNUpKtVTU36zqWK8/f7vMc7p699fz1OTQ0Dxw8tL4KuGWhNkn2BQ4A/rfHmiRJI/oMgi3A2iSHJNkPOAnYNNJmE/DSbvlE4J+raocegSSpP70NDXVj/icDFwD7AGdV1TVJTge2VtUm4L3AB5JsY9ATOKmven5ILPvhrRnz/O0+z+Hu2SvPX/wDXJLa5p3FktQ4g0CSGmcQSFLjDAJJapxB0JMk+yb5rSSfTnJlkiuSfCrJbyf5kVnXt5wl2Suv3JBmxauGepLkHOAbDJ6lNN9tXsXgvokDq+pFs6ptOUhy4EK7gCuqatU061mOkhwA/CHwPGBlt/lW4OPAGVX1jVnVttwl+VRVHTfrOvaUPh8x0bojq+rQkW3zwCVJvjSLgpaZ24CbuO9jSKpbf8RMKlp+zgP+GTimqv4bIMmPMfhj5CPAc2ZY2w+9JEcutAt48jRr6ZtB0J/bk7wA+Ieq+gFAkvsBLwBun2lly8MNwLOq6iujO5LcPKa9drSmqu7zmLIuEF6f5DdnVNNysgX4LOOfifawKdfSK4OgPycxeL/CmUm2d8EfBlzI3n8H9Z7wFuDhwA5BALxhyrUsVzcl+QPg7Kr6GkCSRwK/zn2fDKzxrgN+q6q+PLpjb/tjxDmCHiU5jME7Fw5i8JiNrwAfr6rrZlrYMpHkCdx7/orBQws3ef4mk+ThwKkMzuH24bSvMXjG1xlVZc90EUlOBK6qqh0ee5/keVX1sRmU1QuvGupJktcAH2bwH9gXgH/tdp0z7rWduq/uL9lzGXTLv8igmx48fxOrqtur6jVV9YSqOrD7OayqXsNgAlmLqKrzx4VA5+FTLaZn9gh60k0I/0RVfW9k+37ANVW1djaVLQ+ev34l+UpVrZ51HcvV3nb+nCPozw+AH2dw5cuwR3X7tDjP325KcuVCu4BHTrOW5ail82cQ9OcU4DNJvsy9E3OrgccBJ8+squXD87f7Hgn8IjtepRbuHarUwpo5fwZBT6rq00keDxzFYLIzDO4j2FJV359pccuA52+P+ATwkKq6fHRHkoumX86y08z5c45AkhrnVUOS1DiDQJIaZxCoOUnWJLl6zPb3JFnXLf/RBMc5JcmDFtl/z/GkH2bOEag5SdYAn6iqJy7S5ltV9ZAljnMjMFdVXx+zbx8ntbVc2CNQq/ZNcnb3rojzkzwoyUVJ5pKcATwwyeVJPpTkwUk+2b1T4uokL0rySgb3OVyY5EIYhEeS05N8AXjq9uMN7fuL7hiXdM/8Iclju/Ut3We/1W1/VJLPdTVcneRnZ3Oa1AKDQK06FNhYVU8C7gBesX1HVZ0KfKeqnlxVvwIcC9xSVYd3vYhPV9XbGDz76JlV9czuow8Grq6qo6vq4pHvezBwSVUdDnwOeHm3/a3AW6vqp7rjbfdi4IKqejJwOLDDJYzSnmIQqFU3V9Xnu+UPAk9fpO1VwLOTvD7Jz1bVNxdo933gHxbYdxeD69IBLgXWdMtPZfBuABg8m2q7LcBvJHkd8JNVdeci9Um7xSBQq0YnxxacLKuqLwFPYRAIf5nktAWafneReYHv1b0Tct9niZs5q+pzwM8BXwU+kOQli7WXdodBoFatTvLUbnk9MDqU873t75ZO8uPAt6vqg8BfAdvfXHUnsP9u1nEJ8Pxu+Z73VCR5NHBrVb0beO/Qd0p7nEGgVl0HvLR7sNiBwDtH9m8ErkzyIeAngS8muRz4Y+DPh9p8avtk8S46BXhVki8yeKDe9mGnY4DLk1zGICjeuhvfIS3Ky0elGeruQ/hOVVWSk4D1VXXCrOtSW3zonDRbTwHekSTANwDfJayps0cgSY1zjkCSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ17v8BVnjVjbMQPTQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Demonstration of CNOT - on calssic bits and on qubits\n",
    "circ=Circuit()\n",
    "\n",
    "circ.x(1)\n",
    "#circ.h(0)\n",
    "circ.cnot(1,0)\n",
    "circ.probability()\n",
    "\n",
    "print(circ)\n",
    "\n",
    "task=device.run(circ,shots=1000)\n",
    "results=task.result()\n",
    "\n",
    "probs_values = results.values[0]\n",
    "print(results.measurement_probabilities)\n",
    "\n",
    "\n",
    "# bitstrings\n",
    "format_bitstring = '{0:0' + str(2) + 'b}'\n",
    "bitstring_keys = [format_bitstring.format(ii) for ii in range(2**2)]\n",
    "    \n",
    "# plot probabalities\n",
    "plt.bar(bitstring_keys, probs_values);\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('probability');\n",
    "plt.xticks(rotation=90);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|\n",
      "          \n",
      "q0 : -H-C-\n",
      "        | \n",
      "q1 : -H-C-\n",
      "        | \n",
      "q2 : ---X-\n",
      "\n",
      "T  : |0|1|\n",
      "{'111': 0.245, '100': 0.255, '000': 0.25, '010': 0.25}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Demonstration of CNOT - on calssic bits and on qubits - multigate \n",
    "\n",
    "circ=Circuit()\n",
    "\n",
    "circ.h(0)\n",
    "#circ.x(0)\n",
    "circ.h(1)\n",
    "#circ.x(1)\n",
    "circ.ccnot(0,1,2)\n",
    "\n",
    "circ.probability()\n",
    "print(circ)\n",
    "\n",
    "task=device.run(circ,shots=1000)\n",
    "results=task.result()\n",
    "\n",
    "probs_values = results.values[0]\n",
    "print(results.measurement_probabilities)\n",
    "\n",
    "# bitstrings\n",
    "format_bitstring = '{0:0' + str(3) + 'b}'\n",
    "bitstring_keys = [format_bitstring.format(ii) for ii in range(2**3)]\n",
    "    \n",
    "# plot probabalities\n",
    "plt.bar(bitstring_keys, probs_values);\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('probability');\n",
    "plt.xticks(rotation=90);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0| 1  |\n",
      "             \n",
      "q0 : -X-SWAP-\n",
      "        |    \n",
      "q1 : ---SWAP-\n",
      "\n",
      "T  : |0| 1  |\n",
      "{'01': 1.0}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Swap gate to swap values of qubits\n",
    "\n",
    "circ=Circuit()\n",
    "\n",
    "circ.x(0)\n",
    "#circ.h(0)\n",
    "circ.swap(0,1)\n",
    "\n",
    "circ.probability()\n",
    "print(circ)\n",
    "\n",
    "task=device.run(circ,shots=1000)\n",
    "results=task.result()\n",
    "\n",
    "probs_values = results.values[0]\n",
    "print(results.measurement_probabilities)\n",
    "\n",
    "# bitstrings\n",
    "format_bitstring = '{0:0' + str(2) + 'b}'\n",
    "bitstring_keys = [format_bitstring.format(ii) for ii in range(2**2)]\n",
    "    \n",
    "# plot probabalities\n",
    "plt.bar(bitstring_keys, probs_values);\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('probability');\n",
    "plt.xticks(rotation=90);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Theta: 1.57 \n",
      "\n",
      "T  : |   0    |Result Types|\n",
      "                            \n",
      "q0 : -Rx(1.57)-Probability--\n",
      "               |            \n",
      "q1 : -Ry(1.57)-Probability--\n",
      "\n",
      "T  : |   0    |Result Types|\n",
      "{'00': 0.257, '10': 0.239, '01': 0.252, '11': 0.252}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Phase shift gates are single qubit operations along x,y,x axis \n",
    "## controlled shifts using cx,cy,cz\n",
    "\n",
    "import numpy as np \n",
    "\n",
    "circ=Circuit()\n",
    "\n",
    "theta = np.radians(90)   #shifting the qubit by pi/2\n",
    "   \n",
    "print('Theta:',round(theta,2),'\\n')\n",
    "\n",
    "circ.rx(0,theta)\n",
    "circ.ry(1,theta)\n",
    "circ.probability()\n",
    "print(circ)\n",
    "\n",
    "task=device.run(circ,shots=1000)\n",
    "results=task.result()\n",
    "\n",
    "probs_values=results.values[0]\n",
    "print(results.measurement_probabilities)\n",
    "\n",
    "# bitstrings\n",
    "format_bitstring = '{0:0' + str(2) + 'b}'\n",
    "bitstring_keys = [format_bitstring.format(ii) for ii in range(2**2)]\n",
    "    \n",
    "# plot probabalities\n",
    "plt.bar(bitstring_keys, probs_values);\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('probability');\n",
    "plt.xticks(rotation=90);\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Braket Result Types\n",
    "\n",
    "* Amplitude\n",
    "* Expectation\n",
    "* Probability\n",
    "* State vector\n",
    "* Sample\n",
    "* Variance\n",
    "\n",
    "###### Here we demonstrate just sample type and calculate expectation out of sample results.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|Result Types|\n",
      "                     \n",
      "q0 : -H-C-Sample(X)----\n",
      "        |            \n",
      "q1 : -H-C-Sample(Y)----\n",
      "        |            \n",
      "q2 : ---X-Sample(Z)----\n",
      "\n",
      "T  : |0|1|Result Types|\n",
      "\n",
      "Results:\n",
      "X = 3.0\n",
      "Y = 1.0307692307692307\n",
      "Z = 0.8461538461538461\n"
     ]
    }
   ],
   "source": [
    "#Observables - real values that helps to measure the state of the system \n",
    "from braket.circuits import Observable\n",
    "circ=Circuit()\n",
    "\n",
    "circ.h(0)\n",
    "circ.h(1)\n",
    "circ.ccnot(0,1,2)\n",
    "\n",
    "circ.sample(observable=Observable.X(), target=0)\n",
    "circ.sample(observable=Observable.Y(), target=1)\n",
    "circ.sample(observable=Observable.Z(), target=2)\n",
    "\n",
    "print(circ)\n",
    "\n",
    "task=device.run(circ,shots=1000)\n",
    "result=task.result()\n",
    "\n",
    "print('\\nResults:')\n",
    "for label, res in zip(('X', 'Y', 'Z'), list(result.values)):\n",
    "    expectation = 1 - 2 * np.mean(res[result.measurements[:,0]==1])\n",
    "    print('{} = {}'.format(label, expectation))"
   ]
  },
  {
   "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": 2
}