IonQ.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum prisoners:Implementing quantum game theory with trapped ions\n",
    "### Changhao Li, Wenchao Xu, Guoqing Wang\n",
    "#### Masachusetts Institute of Technology, 2022 Jan\n",
    "### changhao@mit.edu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reference: \n",
    "Phys. Rev. Lett. 88, 137902 (2002)\n",
    "\n",
    "J. Phys. A: Math. Gen. 36 (2003) 6551–6562\n",
    "\n",
    "New J. Phys. 12 063031 （2010）\n",
    "\n",
    "Quantum Information Processing (2018) 17:309"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "from azure.quantum.qiskit import AzureQuantumProvider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from math import pi\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit import BasicAer\n",
    "from qiskit.quantum_info.operators import Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "provider = AzureQuantumProvider(\n",
    "  resource_id=\"/subscriptions/b1d7f7f8-743f-458e-b3a0-3e09734d716d/resourceGroups/aq-hackathons/providers/Microsoft.Quantum/Workspaces/aq-hackathon-01\",\n",
    "  location=\"East US\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ionq.qpu', 'ionq.simulator']\n"
     ]
    }
   ],
   "source": [
    "print([backend.name() for backend in provider.backends()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "qasm_backend = BasicAer.get_backend('qasm_simulator')\n",
    "simulator_backend = provider.get_backend(\"ionq.simulator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creation of circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌────────┐     ┌────┐    ┌──────────┐                   ┌────┐   »\n",
       "q751_0: ┤ Rz(-π) ├─────┤ √X ├────┤ Rz(-π/2) ├─────────────■─────┤ √X ├───»\n",
       "        └─┬────┬─┘┌────┴────┴───┐└──┬────┬──┘┌─────────┐┌─┴─┐┌──┴────┴──┐»\n",
       "q751_1: ──┤ √X ├──┤ Rz(-3.1403) ├───┤ √X ├───┤ Rz(π/2) ├┤ X ├┤ Rz(-π/2) ├»\n",
       "          └────┘  └─────────────┘   └────┘   └─────────┘└───┘└──────────┘»\n",
       " c47: 2/═════════════════════════════════════════════════════════════════»\n",
       "                                                                         »\n",
       "«        ┌────────┐                     \n",
       "«q751_0: ┤ Rz(-π) ├─────────────────────\n",
       "«        └─┬────┬─┘┌─────────────┐┌────┐\n",
       "«q751_1: ──┤ √X ├──┤ Rz(-1.5695) ├┤ √X ├\n",
       "«          └────┘  └─────────────┘└────┘\n",
       "« c47: 2/═══════════════════════════════\n",
       "«                                       </pre>"
      ],
      "text/plain": [
       "        ┌────────┐     ┌────┐    ┌──────────┐                   ┌────┐   »\n",
       "q751_0: ┤ Rz(-π) ├─────┤ √X ├────┤ Rz(-π/2) ├─────────────■─────┤ √X ├───»\n",
       "        └─┬────┬─┘┌────┴────┴───┐└──┬────┬──┘┌─────────┐┌─┴─┐┌──┴────┴──┐»\n",
       "q751_1: ──┤ √X ├──┤ Rz(-3.1403) ├───┤ √X ├───┤ Rz(π/2) ├┤ X ├┤ Rz(-π/2) ├»\n",
       "          └────┘  └─────────────┘   └────┘   └─────────┘└───┘└──────────┘»\n",
       " c47: 2/═════════════════════════════════════════════════════════════════»\n",
       "                                                                         »\n",
       "«        ┌────────┐                     \n",
       "«q751_0: ┤ Rz(-π) ├─────────────────────\n",
       "«        └─┬────┬─┘┌─────────────┐┌────┐\n",
       "«q751_1: ──┤ √X ├──┤ Rz(-1.5695) ├┤ √X ├\n",
       "«          └────┘  └─────────────┘└────┘\n",
       "« c47: 2/═══════════════════════════════\n",
       "«                                       "
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a Quantum Circuit acting on the q register\n",
    "q = QuantumRegister(2)\n",
    "c = ClassicalRegister(2)\n",
    "\n",
    "gamma = pi/4  #gamma=0 (1) corresponds to seperable (maximal entangled) states.\n",
    "circuit = QuantumCircuit(q,c)\n",
    "circuit.name = \"2players\"\n",
    "\n",
    "Jmatrix = Operator([[np.cos(gamma/2),0,0,-1j*np.sin(gamma/2)],[0,np.cos(gamma/2),1j*np.sin(gamma/2),0],[0,1j*np.sin(gamma/2),np.cos(gamma/2),0],[-1j*np.sin(gamma/2),0,0,np.cos(gamma/2)]])\n",
    "Jinverse = Jmatrix.adjoint()\n",
    "\n",
    "circuit.append(Jmatrix,[q[0],q[1]])\n",
    "circuit.append(Q,[q[0]])\n",
    "circuit.append(D,[q[1]])\n",
    "circuit.append(Jinverse,[q[0],q[1]])  \n",
    "circuit = transpile(circuit,qasm_backend,basis_gates=['id','sx','cx','rz','x','y','z'],optimization_level=3)\n",
    "circuit.measure(q,c)\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.+0.j,  0.+0.j,  0.+1.j,  0.+0.j],\n",
       "       [ 0.+0.j,  0.+0.j,  0.+0.j, -0.-1.j],\n",
       "       [-0.-1.j,  0.+0.j,  0.+0.j,  0.+0.j],\n",
       "       [ 0.+0.j,  0.+1.j,  0.+0.j,  0.+0.j]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## uncomment the text below to get the effective unitary evolution matrix\n",
    "## note that circuit.measure(q,c) should not be included to compute the following unitary\n",
    "\n",
    "#backend = BasicAer.get_backend('unitary_simulator')\n",
    "#job = backend.run(transpile(circuit, backend))\n",
    "#job.result().get_unitary(circuit, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we next simuate the above circuit using the simulator backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job id fadb4b38-8159-11ec-9240-38f9d3315497\n",
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "job = simulator_backend.run(circuit, shots=100)\n",
    "job_id = job.id()\n",
    "print(\"Job id\", job_id)\n",
    "job_monitor(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result(backend_name='ionq.simulator', backend_version='1', qobj_id='2players', job_id='fadb4b38-8159-11ec-9240-38f9d3315497', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts=defaultdict(<class 'int'>, {'10': 100}), probabilities=defaultdict(<class 'int'>, {'10': 1})), header=QobjExperimentHeader(meas_map='[0, 1]', name='2players', num_qubits='2', qiskit='True'))])\n",
      "{'00': 0, '01': 0, '10': 100, '11': 0}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = job.result()\n",
    "type(result)\n",
    "print(result)\n",
    "counts = {format(n, \"02b\"): 0 for n in range(4)}\n",
    "counts.update(result.get_counts(circuit))\n",
    "print(counts)\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the unitary evolution matrix for a single qubit\n",
    "def unitary(theta,phi):\n",
    "    return Operator([[np.exp(1j*phi)*np.cos(theta/2),np.sin(theta/2)],[-np.sin(theta/2),np.exp(-1j*phi)*np.cos(theta/2)]])\n",
    "Q = unitary(0,np.pi/2)\n",
    "D = unitary(np.pi,0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## define the function for simulation\n",
    "\n",
    "def prob_simu(gamma,shots,strategy,if_draw_circuit):\n",
    "    ## gamma: the target entangled state that one creates with Jmatrix\n",
    "    ## shots: number of shots in simulator backend\n",
    "    ## strategy: local operations performed by Alice (q[0]) and Bob (q[1])\n",
    "    ## if_draw_circuit: option to draw the cirucuit\n",
    "    ## Return a list of number of shots in the computational basis of the qubits.\n",
    "    \n",
    "    q = QuantumRegister(2)\n",
    "    c = ClassicalRegister(2)\n",
    "\n",
    "    circuit = QuantumCircuit(q,c)\n",
    "    circuit.name = \"2players\"\n",
    "    \n",
    "    Jmatrix = Operator([[np.cos(gamma/2),0,0,-1j*np.sin(gamma/2)],[0,np.cos(gamma/2),1j*np.sin(gamma/2),0],[0,1j*np.sin(gamma/2),np.cos(gamma/2),0],[-1j*np.sin(gamma/2),0,0,np.cos(gamma/2)]])\n",
    "    Jtemp = Jmatrix.transpose()\n",
    "    Jinverse = Jtemp.conjugate()\n",
    "\n",
    "    circuit.append(Jmatrix,[q[0],q[1]])\n",
    "\n",
    "    if strategy == 'QD':\n",
    "        circuit.append(Q,[q[0]]);circuit.append(D,[q[1]]) # operation Q+D in Du's RPL\n",
    "    if strategy == 'DD':\n",
    "        circuit.append(D,[q[0]]);circuit.append(D,[q[1]]) # operation D+D in Du's RPL\n",
    "    if strategy == 'QQ':\n",
    "        circuit.append(Q,[q[0]]);circuit.append(Q,[q[1]]) # operation Q+Q in Du's RPL\n",
    "    \n",
    "    circuit.append(Jinverse,[q[0],q[1]])\n",
    "    \n",
    "\n",
    "    circuit = transpile(circuit,qasm_backend,basis_gates=['id','sx','cx','rz','x'],optimization_level=3)\n",
    "    circuit.measure(q,c)\n",
    "    if if_draw_circuit==1: \n",
    "        circuit.draw()\n",
    "        \n",
    "    job = simulator_backend.run(circuit, shots=100)\n",
    "    job_id = job.id()\n",
    "    #print(\"Job id\", job_id)\n",
    "    job_monitor(job)\n",
    "    \n",
    "    result = job.result()\n",
    "    counts = {format(n, \"02b\"): 0 for n in range(4)}\n",
    "    counts.update(result.get_counts(circuit))\n",
    "    plot_histogram(counts)  \n",
    "    \n",
    "    return list(counts.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "[0, 0, 100, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 0, 99, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 2, 97, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 5, 94, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 9, 90, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 14, 85, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 20, 79, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 27, 72, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 34, 65, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 42, 57, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 50, 50, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 57, 42, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 65, 34, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 72, 27, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 79, 20, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 85, 14, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 90, 9, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 94, 5, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 97, 2, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 99, 0, 0]\n",
      "Job Status: job has successfully run\n",
      "[0, 100, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "if_draw_circuit = 1\n",
    "shots = 100\n",
    "strategy = 'QD'\n",
    "\n",
    "gamma_list = np.linspace(0,pi/2,21)\n",
    "result_list = []\n",
    "for gamma in gamma_list:\n",
    "    tmp= prob_simu(gamma,shots,strategy, if_draw_circuit)\n",
    "    print(tmp)\n",
    "    result_list.append(tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x152298590>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "res = np.array(result_list).T.tolist()\n",
    "plt.figure()\n",
    "plt.plot(gamma_list,res[1],'.')\n",
    "plt.xlabel('\\gamma')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IonQ implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prob_ionQ(gamma,shots,strategy):\n",
    "    \n",
    "    ## gamma: the target entangled state that one creates with Jmatrix\n",
    "    ## shots: number of shots in simulator backend (dummy variable here)\n",
    "    ## strategy: local operations performed by Alice (q[0]) and Bob (q[1])\n",
    "    ## Return a list of number of shots in the computational basis of the qubits.\n",
    "    \n",
    "    q = QuantumRegister(2)\n",
    "    c = ClassicalRegister(2)\n",
    "\n",
    "    circuit = QuantumCircuit(q,c)\n",
    "    circuit.name = \"2players\"\n",
    "    \n",
    "    Jmatrix = Operator([[np.cos(gamma/2),0,0,-1j*np.sin(gamma/2)],[0,np.cos(gamma/2),1j*np.sin(gamma/2),0],[0,1j*np.sin(gamma/2),np.cos(gamma/2),0],[-1j*np.sin(gamma/2),0,0,np.cos(gamma/2)]])\n",
    "    Jtemp = Jmatrix.transpose()\n",
    "    Jinverse = Jtemp.conjugate()\n",
    "\n",
    "    circuit.append(Jmatrix,[q[0],q[1]])\n",
    "\n",
    "    if strategy == 'QD':\n",
    "        circuit.append(Q,[q[0]]);circuit.append(D,[q[1]]) # operation Q+D in Du's RPL\n",
    "    if strategy == 'DD':\n",
    "        circuit.append(D,[q[0]]);circuit.append(D,[q[1]]) # operation D+D in Du's RPL\n",
    "    if strategy == 'QQ':\n",
    "        circuit.append(Q,[q[0]]);circuit.append(Q,[q[1]]) # operation Q+Q in Du's RPL\n",
    "    \n",
    "    circuit.append(Jinverse,[q[0],q[1]])\n",
    "    \n",
    "\n",
    "    circuit = transpile(circuit,qasm_backend,basis_gates=['id','sx','cx','rz','x'],optimization_level=3)\n",
    "    circuit.measure(q,c) \n",
    "    circuit.draw()\n",
    "        \n",
    "    job = qpu_backend.run(circuit, shots=512)\n",
    "    job_id = job.id()\n",
    "    #print(\"Job id\", job_id)\n",
    "    job_monitor(job)\n",
    "    \n",
    "    result = job.result()\n",
    "    counts = {format(n, \"02b\"): 0 for n in range(4)}\n",
    "    counts.update(result.get_counts(circuit))\n",
    "    plot_histogram(counts)   \n",
    "    return list(counts.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.15707963267948966\n",
      "Job Status: job has successfully run\n",
      "[7, 30, 458, 17]\n",
      "0.3141592653589793\n",
      "Job Status: job has successfully run\n",
      "[6, 78, 409, 19]\n",
      "0.47123889803846897\n",
      "Job Status: job has successfully run\n",
      "[5, 114, 357, 36]\n",
      "0.6283185307179586\n",
      "Job Status: job has successfully run\n",
      "[25, 190, 285, 12]\n",
      "0.7853981633974483\n",
      "Job Status: job has successfully run\n",
      "[9, 193, 299, 11]\n",
      "0.9424777960769379\n",
      "Job Status: job has successfully run\n",
      "[12, 280, 209, 11]\n",
      "1.0995574287564276\n",
      "Job Status: job has successfully run\n",
      "[9, 355, 144, 4]\n",
      "1.2566370614359172\n",
      "Job Status: job has successfully run\n",
      "[14, 404, 93, 1]\n",
      "1.413716694115407\n",
      "Job Status: job has successfully run\n",
      "[13, 469, 28, 2]\n",
      "1.5707963267948966\n",
      "Job Status: job has successfully run\n",
      "[2, 510, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "qpu_backend = provider.get_backend(\"ionq.qpu\")\n",
    "\n",
    "\n",
    "## run for strategy QD\n",
    "\n",
    "if_draw_circuit = 1\n",
    "shots = 100\n",
    "strategy = 'QD'\n",
    "\n",
    "gamma_list = np.linspace(pi/2/10,pi/2,10)\n",
    "result_list = []\n",
    "for gamma in gamma_list:\n",
    "    print(gamma)\n",
    "    tmp= prob_ionQ(gamma,shots,strategy)\n",
    "    print(tmp)\n",
    "    result_list.append(tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7, 6, 5, 25, 9, 12, 9, 14, 13, 2], [30, 78, 114, 190, 193, 280, 355, 404, 469, 510], [458, 409, 357, 285, 299, 209, 144, 93, 28, 0], [17, 19, 36, 12, 11, 11, 4, 1, 2, 0]]\n"
     ]
    }
   ],
   "source": [
    "QD_res = np.array(result_list).T.tolist()\n",
    "print(QD_res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "Job Status: job has successfully run\n",
      "[510, 1, 1, 0]\n",
      "0.15707963267948966\n",
      "Job Status: job has successfully run\n",
      "[508, 2, 2, 0]\n",
      "0.3141592653589793\n",
      "Job Status: job has successfully run\n",
      "[509, 2, 1, 0]\n",
      "0.47123889803846897\n",
      "Job Status: job has successfully run\n",
      "[510, 1, 1, 0]\n",
      "0.6283185307179586\n",
      "Job Status: job has successfully run\n",
      "[510, 2, 0, 0]\n",
      "0.7853981633974483\n",
      "Job Status: job has successfully run\n",
      "[511, 1, 0, 0]\n",
      "0.9424777960769379\n",
      "Job Status: job has successfully run\n",
      "[512, 0, 0, 0]\n",
      "1.0995574287564276\n",
      "Job Status: job has successfully run\n",
      "[508, 3, 1, 0]\n",
      "1.2566370614359172\n",
      "Job Status: job has successfully run\n",
      "[512, 0, 0, 0]\n",
      "1.413716694115407\n",
      "Job Status: job has successfully run\n",
      "[512, 0, 0, 0]\n",
      "1.5707963267948966\n",
      "Job Status: job has successfully run\n",
      "[508, 0, 4, 0]\n",
      "[[510, 508, 509, 510, 510, 511, 512, 508, 512, 512, 508], [1, 2, 2, 1, 2, 1, 0, 3, 0, 0, 0], [1, 2, 1, 1, 0, 0, 0, 1, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "## run for strategy QQ\n",
    "\n",
    "shots = 100\n",
    "strategy = 'QQ'\n",
    "\n",
    "gamma_list = np.linspace(0,pi/2,11)\n",
    "QQ_result_list = []\n",
    "for gamma in gamma_list:\n",
    "    print(gamma)\n",
    "    tmp= prob_ionQ(gamma,shots,strategy)\n",
    "    print(tmp)\n",
    "    QQ_result_list.append(tmp)\n",
    "QQ_res = np.array(QQ_result_list).T.tolist()\n",
    "print(QQ_res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "Job Status: job has successfully run\n",
      "[0, 7, 5, 500]\n",
      "0.15707963267948966\n",
      "Job Status: job has successfully run\n",
      "[0, 7, 7, 498]\n",
      "0.3141592653589793\n",
      "Job Status: job has successfully run\n",
      "[0, 4, 2, 506]\n",
      "0.47123889803846897\n",
      "Job Status: job has successfully run\n",
      "[0, 4, 12, 496]\n",
      "0.6283185307179586\n",
      "Job Status: job has successfully run\n",
      "[2, 3, 4, 503]\n",
      "0.7853981633974483\n",
      "Job Status: job has successfully run\n",
      "[0, 8, 4, 500]\n",
      "0.9424777960769379\n",
      "Job Status: job has successfully run\n",
      "[0, 5, 5, 502]\n",
      "1.0995574287564276\n",
      "Job Status: job has successfully run\n",
      "[1, 4, 12, 495]\n",
      "1.2566370614359172\n",
      "Job Status: job has successfully run\n",
      "[0, 7, 7, 498]\n",
      "1.413716694115407\n",
      "Job Status: job has successfully run\n",
      "[0, 2, 6, 504]\n",
      "1.5707963267948966\n",
      "Job Status: job has successfully run\n",
      "[0, 5, 4, 503]\n",
      "[[0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0], [7, 7, 4, 4, 3, 8, 5, 4, 7, 2, 5], [5, 7, 2, 12, 4, 4, 5, 12, 7, 6, 4], [500, 498, 506, 496, 503, 500, 502, 495, 498, 504, 503]]\n"
     ]
    }
   ],
   "source": [
    "## run for strategy DD\n",
    "shots = 100\n",
    "strategy = 'DD'\n",
    "\n",
    "gamma_list = np.linspace(0,pi/2,11)\n",
    "DD_result_list = []\n",
    "for gamma in gamma_list:\n",
    "    print(gamma)\n",
    "    tmp= prob_ionQ(gamma,shots,strategy)\n",
    "    print(tmp)\n",
    "    DD_result_list.append(tmp)\n",
    "DD_res = np.array(DD_result_list).T.tolist()\n",
    "print(DD_res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "temp1= [x/512*3 for x in QQ_res[0]]; temp2= [x/512*5 for x in QQ_res[2]]\n",
    "QQ_final = [a + b for a, b in zip(temp1, temp2)]\n",
    "\n",
    "\n",
    "temp1= [x/512*3 for x in DD_res[0]]; temp2= [x/512*5 for x in DD_res[2]]; temp3= [x/512*1 for x in DD_res[3]]\n",
    "DD_final = [a + b+c for a, b, c in zip(temp1, temp2,temp3)]\n",
    "\n",
    "temp1= [x/512*3 for x in QD_res[0]]; temp2= [x/512*5 for x in QD_res[2]]; temp3= [x/512*1 for x in QD_res[3]]\n",
    "QD_final = [a + b+c for a, b, c in zip(temp1, temp2,temp3)]\n",
    "QD_final = [(6*3+1015*5+3*1)/1024] + QD_final\n",
    "\n",
    "temp1= [x/512*3 for x in QD_res[0]]; temp2= [x/512*5 for x in QD_res[1]]; temp3= [x/512*1 for x in QD_res[3]]\n",
    "DQ_final = [a + b+c for a, b, c in zip(temp1, temp2,temp3)]\n",
    "DQ_final = [(6*3+1015*0+3*1)/1024] + DQ_final\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(gamma_list,QD_final,'.',label='QD')\n",
    "plt.plot(gamma_list,DQ_final,'.',label='DQ')\n",
    "plt.plot(gamma_list,QQ_final,'.',label='QQ')\n",
    "plt.plot(gamma_list,DD_final,'.',label='DD')\n",
    "plt.xlabel('gamma')\n",
    "plt.ylabel('Payoff')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x14a8d0390>]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "temp1= [x/512*3 for x in QD_res[0]]; temp2= [x/512*5 for x in QD_res[1]]; temp3= [x/512*1 for x in QD_res[3]]\n",
    "DQ_final = [a + b+c for a, b, c in zip(temp1, temp2,temp3)]\n",
    "DQ_final = [(6*3+1015*0+3*1)/1024] + DQ_final\n",
    "plt.figure()\n",
    "plt.plot(gamma_list,DQ_final,'.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally we summarize and plot the results above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "QD_simu = np.array([5.0, 4.8, 4.4, 3.75, 2.9, 2.05, 1.25, 0.55, 0.15, 0.0])\n",
    "QQ_simu = np.array([3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])\n",
    "DD_simu = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n",
    "DQ_simu = np.array([0.0,0.15,0.55,1.25,2.05,2.9,3.75,4.4,4.8,5.0])\n",
    "gamma_table_simu = np.pi/2*np.linspace(0,1,10)\n",
    "\n",
    "\n",
    "QQ_exp = np.array([2.99804688, 2.99609375, 2.9921875 , 2.99804688, 2.98828125,\n",
    "       2.99414062, 3.        , 2.98632812, 3.        , 3.        ,\n",
    "       3.015625  ]);      \n",
    "QD_exp = np.array([4.9765625 , 4.546875  , 4.06640625, 3.5859375 , 2.953125  ,\n",
    "       2.99414062, 2.1328125 , 1.46679688, 0.9921875 , 0.35351562,\n",
    "       0.01171875]);          \n",
    "DD_exp = np.array([1.02539062, 1.04101562, 1.0078125 , 1.0859375 , 1.03320312,\n",
    "       1.015625  , 1.02929688, 1.08984375, 1.04101562, 1.04296875,\n",
    "       1.02148438]);\n",
    "DQ_exp = np.array([0.02050781, 0.3671875 , 0.83398438, 1.21289062, 2.02539062,\n",
    "       1.95898438, 2.82617188, 3.52734375, 4.02929688, 4.66015625,\n",
    "       4.9921875 ])\n",
    "gamma_table = np.pi/2*np.linspace(0,1,11)\n",
    "\n",
    "\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "plt.plot(gamma_table_simu, QQ_simu,'r-',label=\"QQ Simu.\")\n",
    "plt.plot(gamma_table_simu, QD_simu,'g-',label=\"QD Simu.\")\n",
    "plt.plot(gamma_table_simu, DQ_simu,'m-',label=\"DQ Simu.\")\n",
    "plt.plot(gamma_table_simu, DD_simu,'b-',label=\"DD Simu.\")\n",
    "\n",
    "\n",
    "plt.plot(gamma_table, QQ_exp,'r^',label=\"QQ QPU\",markersize=8)\n",
    "plt.plot(gamma_table, QD_exp,'g^',label=\"QD QPU\",markersize=8)\n",
    "plt.plot(gamma_table, DQ_exp,'m^',label=\"DQ QPU\",markersize=8)\n",
    "plt.plot(gamma_table, DD_exp,'b^',label=\"DD QPU\",markersize=8)\n",
    "\n",
    "gamma_nash = np.linspace(0,np.arcsin(np.sqrt(1/5)),10)\n",
    "payoff_nash =np.array([1 for i in range(10)])\n",
    "gamma_nash_2 = np.linspace(np.arcsin(np.sqrt(1/5)),np.arcsin(np.sqrt(2/5)),8)\n",
    "payoff_nash_2 = 5*np.multiply(np.cos(gamma_nash_2),np.cos(gamma_nash_2))\n",
    "gamma_nash_3 = np.linspace(np.arcsin(np.sqrt(1/5)),np.arcsin(np.sqrt(2/5)),8)\n",
    "payoff_nash_3 = 5*np.multiply(np.sin(gamma_nash_2),np.sin(gamma_nash_2))\n",
    "gamma_nash_4 = np.linspace(np.arcsin(np.sqrt(2/5)),np.pi/2,20)\n",
    "payoff_nash_4 =np.array([3 for i in range(20)])\n",
    "plt.plot(gamma_nash, payoff_nash,'kx',label=\"Nash Equi\",markersize=12)\n",
    "plt.plot(gamma_nash_2, payoff_nash_2,'kx',markersize=8)\n",
    "plt.plot(gamma_nash_3, payoff_nash_3,'kx',markersize=8)\n",
    "plt.plot(gamma_nash_4, payoff_nash_4,'kx',markersize=8)\n",
    "\n",
    "\n",
    "plt.xlabel(r'$\\gamma$')\n",
    "plt.ylabel('Payoff for Bob')\n",
    "plt.title('Simulator (100 shot) and QPU data (512 shot)')\n",
    "plt.rcParams.update({'font.size': 20})\n",
    "plt.legend(loc=1,fontsize=10,ncol=3)\n",
    "plt.savefig('Alice_Bob_payoff.pdf')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "azurequantum",
   "language": "python",
   "name": "azurequantum"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}