GHZ game.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html><script type=\"math/tex; mode=display\">\\newcommand{\\Bold}[1]{\\mathbf{#1}}1</script></html>"
      ],
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "# Define Paulis and Hadamard\n",
    "iden2 = Matrix.identity(2)\n",
    "H = 1/sqrt(2)* Matrix([[1, 1],[1, -1]])\n",
    "Z = Matrix([[1, 0], [0, -1]])\n",
    "X = Matrix([[0, 1], [1, 0]])\n",
    "Y = -I*Z*X\n",
    "\n",
    "# Takes a variable number of operators and tensors them\n",
    "tensor = lambda *projections: reduce(lambda a, b: a.tensor_product(b), projections)\n",
    "# Trace of an operator\n",
    "tr = lambda rho: rho.trace()\n",
    "xor = lambda *args: reduce(lambda a, b: (a + b) % 2, args)\n",
    "psi_gen = lambda theta, phi: Matrix([cos(theta), e^(I*phi)*sin(theta)]).transpose()\n",
    "\n",
    "# Inputs in the GHZ game\n",
    "inputs = [(0,0,0), (0, 1, 1), (1, 0, 1), (1, 1, 0)]\n",
    "\n",
    "# Computational basis vectors \n",
    "z = Matrix([1, 0]).transpose() # |0>\n",
    "o = Matrix([0, 1]).transpose() # |1>\n",
    "\n",
    "# Hadamard basis vectors\n",
    "p = 1/sqrt(2) * (z + o) # |+>\n",
    "m = 1/sqrt(2) * (z - o) # |->\n",
    "\n",
    "i_plus = 1/sqrt(2) * (z + I*o)\n",
    "i_minus = 1/sqrt(2) * (z - I*o)\n",
    "\n",
    "# Takes |psi> and returns |psi><psi|\n",
    "proj = lambda psi: psi * psi.conjugate_transpose()\n",
    "ketbra = lambda psi, phi: psi * phi.conjugate_transpose()\n",
    "\n",
    "# Define projectors corresponding to computational and \n",
    "# Hadamard basis\n",
    "zz = proj(z) # |0><0|\n",
    "oo = proj(o) # |1><1|\n",
    "pp = proj(p) # |+><+|\n",
    "mm = proj(m) # |-><-|\n",
    "i_pp = proj(i_plus)\n",
    "i_mm = proj(i_minus)\n",
    "\n",
    "# Projective measurement: \n",
    "# On input 0, measure in Hadamard basis\n",
    "# On input 1, measure in Y basis\n",
    "E = [[pp, mm], [i_pp, i_mm]]\n",
    "#E2 = [[zz, oo], [pp, mm]]\n",
    "# GHZ state\n",
    "ghz_rho = proj(1/sqrt(2) * (tensor(z,z,z) + tensor(o,o,o)))\n",
    "\n",
    "# Born rule for quantum probability\n",
    "p = lambda y_A, y_B, y_C, x_A, x_B, x_C, E, F, G, rho: tr(tensor(E[x_A][y_A], F[x_B][y_B], G[x_C][y_C]) * rho)\n",
    "\n",
    "# Probability of winning the GHZ game\n",
    "pr_win = lambda PI1, PI2, PI3, rho: 1/4 * sum(\n",
    "                                    p(y_A, y_B, y_C, x_A, x_B, x_C, PI1, PI2, PI3, rho) \n",
    "                                        for y_A in range(2) \n",
    "                                        for y_B in range(2) \n",
    "                                        for y_C in range(2)\n",
    "                                        for x_A, x_B, x_C in inputs\n",
    "                                        if xor(y_A, y_B, y_C) == (x_A | x_B | x_C)\n",
    "                                  )\n",
    "show(pr_win(E, E, E, ghz_rho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html><script type=\"math/tex; mode=display\">\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\phi = \\frac{1}{2} \\, \\pi, \\phi = \\pi, \\phi = -\\frac{1}{2} \\, \\pi, \\phi = 0\\right]</script></html>"
      ],
      "text/plain": [
       "[phi == 1/2*pi, phi == pi, phi == -1/2*pi, phi == 0]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<html><script type=\"math/tex; mode=display\">\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\theta = 0, \\theta = \\frac{3}{4} \\, \\pi, \\theta = \\frac{1}{4} \\, \\pi, \\theta = \\frac{1}{2} \\, \\pi\\right]</script></html>"
      ],
      "text/plain": [
       "[theta == 0, theta == 3/4*pi, theta == 1/4*pi, theta == 1/2*pi]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<html><script type=\"math/tex; mode=display\">\\newcommand{\\Bold}[1]{\\mathbf{#1}}1</script></html>"
      ],
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "theta, phi = var('theta phi')\n",
    "q_ket = psi_gen(theta, phi)\n",
    "Q = proj(q_ket)\n",
    "E_jordan = [[pp, mm], [H*Q*H, iden2 - H*Q*H]]\n",
    "show(solve(pr_win(E_jordan, E_jordan, E_jordan, ghz_rho).simplify_trig().differentiate(phi), phi))\n",
    "show(solve(pr_win(E_jordan, E_jordan, E_jordan, ghz_rho).simplify_trig().subs(phi=pi/2).differentiate(theta), theta))\n",
    "show(pr_win(E_jordan, E_jordan, E_jordan, ghz_rho).subs(phi=pi/2, theta=pi/4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.1",
   "language": "sage",
   "name": "sagemath"
  },
  "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
}