Mermin–Peres-Game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mermin Peres Magic Square Game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit_ibm_runtime import Sampler\n",
    "from qiskit_aer import AerSimulator\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_result(results, col, row):\n",
    "    print_tut = True\n",
    "    for i in results: \n",
    "        \n",
    "        if print_tut:\n",
    "            explain(i, col, row)\n",
    "            print_tut = False\n",
    "\n",
    "        print(\"Quantum circuit solution\")\n",
    "        print(i+\"\\n\")\n",
    "        i = np.array(list(i)).astype(int)[::-1]\n",
    "        # bring array in correct i.e. from incoming y2,y1,x2,x1 -> x1,x2,y1,y2\n",
    "        a = i[0:2]\n",
    "        a_sum = np.sum(a)\n",
    "        a3 = int(np.mod(a_sum+1,2))\n",
    "        a = np.append(a,a3)\n",
    "        \n",
    "        winning_alice = np.mod(a_sum + a3, 2) == 1\n",
    "        # compute x3 by x1+x2+1 mod 2 and save to array\n",
    "\n",
    "        b = i[2:]\n",
    "        b_sum = np.sum(b)\n",
    "        b3 = int(np.mod(b_sum,2))\n",
    "        b = np.append(b,b3)\n",
    "        winning_bob = np.mod(b_sum + b3, 2) == 0   \n",
    "        # compute y3 by y1+y2 mod 2 and save to array\n",
    "        \n",
    "        # compute overall winning condition -> alice at index of bob's row and vice versa\n",
    "        print(\"Alice's selection. Column:\"+str(col)+\"\\n\"+str(a.reshape(3,1))+\"\\n\")\n",
    "        print(\"Bob's circuit solution. Row:\"+str(row)+\"\\n\"+str(b)+\"\\n\")\n",
    "        \n",
    "        if(winning_bob & winning_alice & (a[row-1]==b[col-1])):\n",
    "            print(\"Victory!\")    \n",
    "            print(\"The following magic square wins the game!\")\n",
    "            k = np.empty((3,3,))\n",
    "            k[:] = np.nan\n",
    "            k[:,col-1] = a\n",
    "            k[row-1,:] = b\n",
    "            print(k)\n",
    "        else:\n",
    "            print(\"The Game is lost!\")\n",
    "        print(\"------------------------------------------\")  \n",
    "        print(\"\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def explain(result, col, row):\n",
    "    print(\"Resultant quantum circuit solution:\"+\"\\n\")\n",
    "    print(result+\"\\n\")\n",
    "    example = np.array(list(result)).astype(int)[::-1]\n",
    "    print(\"Bring array in correct bit order i.e. from incoming y2,y1,x2,x1 -> x1,x2,y1,y2\"+\"\\n\")\n",
    "    print(str(example)+\"\\n\")\n",
    "    print(\"Compute missing x3 with x1+x2+1 mod 2 for Alice and save to array for further processing\")\n",
    "    print(\"Compute missing y3 with y1+y2 mod 2 for Bob and save to array for further processing\"+\"\\n\")\n",
    "   \n",
    "    a = example[0:2]\n",
    "\n",
    "    a_sum = np.sum(a)\n",
    "    a3 = int(np.mod(a_sum+1,2))\n",
    "    a = np.append(a,a3)\n",
    "\n",
    "    winning_alice = np.mod(a_sum + a3, 2) == 1\n",
    "\n",
    "    b = example[2:]\n",
    "    b_sum = np.sum(b)\n",
    "    b3 = int(np.mod(b_sum,2))\n",
    "    b = np.append(b,b3)\n",
    "    winning_bob = np.mod(b_sum + b3, 2) == 0   \n",
    "\n",
    "    print(\"Alice's column solution\"+\"\\n\"+str(a.reshape(3,1))+\"\\n\" + \"Winning conditions fullfilled (Odd quantitude of 1)?: \"+str(winning_alice)+\"\\n\")\n",
    "    print(\"Bob's row solution\"+\"\\n\"+str(b)+\"\\n\"+ \"Winning conditions fullfilled (Even quantitude of 1)?: \"+str(winning_bob)+\"\\n\")\n",
    "    print(\"Create matrix to show results\"+\"\\n\")\n",
    "    k = np.empty((3,3))\n",
    "    k[:] = np.nan\n",
    "    k[:,col-1] = a\n",
    "    k[row-1,:] = b\n",
    "    print(k)\n",
    "    print(\"------------------------------------------\")  \n",
    "    print(\"------------------------------------------\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def get_state_accuracy(counts): # funciton to calculate state accuracy\n",
    "    expected_counts = 0\n",
    "    for state in counts.keys():\n",
    "        if state in expected_states:\n",
    "            expected_counts = expected_counts + counts[state]\n",
    "    state_accuracy = expected_counts / shots\n",
    "    return str(state_accuracy*100)+\"%\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The following function sets up the initial entanglement between Alice and Bob\n",
    "def share_bell_state(qc,a,b,c,d): \n",
    "    qc.h(a)\n",
    "    qc.h(b)\n",
    "    qc.cx(a,c)\n",
    "    qc.cx(b,d)\n",
    "    \n",
    "# The following functions represent the U(gamma) and V(gamma) controlled Cliffords.\n",
    "def U(qc,gamma,a,b):\n",
    "    if gamma==1:\n",
    "        qc.h(a)\n",
    "        qc.id(b)\n",
    "    elif gamma==2:\n",
    "        qc.swap(a,b)\n",
    "        qc.h(a)\n",
    "        qc.id(b)\n",
    "\n",
    "    elif gamma==3:\n",
    "        qc.cx(a,b)\n",
    "        qc.h(a)\n",
    "        qc.id(b)\n",
    "\n",
    "def V(qc,gamma,a,b):\n",
    "    if gamma==1:\n",
    "        qc.h(a)\n",
    "        qc.h(b)\n",
    "    if gamma==2:\n",
    "        qc.swap(a,b)\n",
    "    elif gamma==3:\n",
    "        qc.z(a)\n",
    "        qc.z(b)\n",
    "        qc.cz(a,b)\n",
    "        qc.h(a)\n",
    "        qc.h(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We will ask the user to select the row and column on Alice and Bob's behalf.\n",
    "print(\"Alice and Bob, select a column or row value of 1, 2, or 3\") \n",
    "print(\"Alice choice (column):\")\n",
    "alpha = int(input())\n",
    "print(alpha)\n",
    "print(\"Bob choice (row):\")\n",
    "beta = int(input())\n",
    "print(beta)\n",
    "\n",
    "#Create the circuit\n",
    "magicsquare_circuit = QuantumCircuit(4,4)\n",
    "\n",
    "#Generate the Bell state on the circuit\n",
    "share_bell_state(magicsquare_circuit,0,1,2,3)\n",
    "\n",
    "magicsquare_circuit.barrier()\n",
    "\n",
    "#Draw the rest of the circuit based on Alice and Bob's selection   \n",
    "if 4>alpha>0 and 4>beta>0:\n",
    "    U(magicsquare_circuit,alpha,0,1) \n",
    "    V(magicsquare_circuit,beta,2,3)\n",
    "    magicsquare_circuit.barrier()\n",
    "    magicsquare_circuit.measure(0,0)\n",
    "    magicsquare_circuit.measure(1,1)\n",
    "    magicsquare_circuit.measure(2,2)\n",
    "    magicsquare_circuit.measure(3,3)\n",
    "    \n",
    "    magicsquare_circuit.draw(output='mpl')\n",
    "    #print(magicsquare_circuit)\n",
    "\n",
    "    backend = AerSimulator() # define the backend\n",
    "    sampler = Sampler(mode=backend)\n",
    "    sampler.options.default_shots=8192\n",
    "    counts = sampler.run([magicsquare_circuit]).result()[0].data.c.get_counts()\n",
    "    check_result(counts, alpha, beta)\n",
    "    print(counts)\n",
    "\n",
    "else:\n",
    "    print(\"please enter values of 1, 2, or 3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}