Mermin-3-test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dependencies\n",
    "import qibo\n",
    "from qibo.models import Circuit\n",
    "from qibo import gates\n",
    "import numpy as np\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate GHZ-like state with relative phase\n",
    "\n",
    "This circuit aims to generate the state $|\\psi\\rangle=1/\\sqrt 2(|000\\rangle + i|111\\rangle)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q0: ─────H─o─H───M─\n",
      "q1: ─H─o─H─|─────M─\n",
      "q2: ───X───X─H─S─M─\n"
     ]
    }
   ],
   "source": [
    "GHZ_3 = Circuit(3)\n",
    "\n",
    "# Apply gates according to the given circuit diagram\n",
    "GHZ_3.add([\n",
    "    gates.H(1),\n",
    "    gates.CNOT(1, 2),\n",
    "    gates.H(1), \n",
    "\n",
    "    gates.H(0),\n",
    "    gates.CNOT(0,2),\n",
    "    gates.H(0),\n",
    "    gates.H(2),\n",
    "    gates.S(2),\n",
    "\n",
    "    gates.M(0,1,2)\n",
    "\n",
    "])\n",
    "\n",
    "print(GHZ_3.draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'111': 507, '000': 493})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Z measurement results on the generation circuit\n",
    "GHZ_result = GHZ_3(nshots=1000)\n",
    "GHZ_result.frequencies()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measurement\n",
    "For 3 qubits, the Mermin polynomial reads\n",
    "$$\n",
    "\\begin{align}\n",
    "M_3 = (a_1a_2a_3' + a_1a_2'a_3 + a_1'a_2a_3 - a_1'a_2'a_3')\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    ", where $a_i$ represents $\\sigma_x$ on the ith qubit, while $a_i'$ represents $\\sigma_y$ on the same qubit.\n",
    "\n",
    "By virtue of symmetry, we can simplify the measurement to:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "M_3 &= 3(a_1a_2a_3') - a_1'a_2'a_3'\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "which only requires 2 experiments.\n",
    "\n",
    "\n",
    "The classical bound of $\\langle M_3\\rangle^{LR}\\le 2$ and the quantum bound $\\langle M_3\\rangle ^{QM} \\le 4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GHZ_3_generate():\n",
    "    circuit = Circuit(3)\n",
    "    circuit.add([\n",
    "    gates.H(1),\n",
    "    gates.CNOT(1, 2),\n",
    "    gates.H(1), \n",
    "\n",
    "    gates.H(0),\n",
    "    gates.CNOT(0,2),\n",
    "    gates.H(0),\n",
    "    gates.H(2),\n",
    "    gates.S(2),\n",
    "])\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q0: ─────H─o─H─H───────M─\n",
      "q1: ─H─o─H─|─H─────────M─\n",
      "q2: ───X───X─H─S─SDG─H─M─\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({'011': 2639, '101': 2472, '000': 2467, '110': 2422})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nshots = 10000\n",
    "meas_xxy = GHZ_3_generate()\n",
    "meas_xxy.add(gates.SDG(2))\n",
    "meas_xxy.add([gates.H(i) for i in range(3)])\n",
    "meas_xxy.add(gates.M(0,1,2))\n",
    "print(meas_xxy.draw())\n",
    "xxy_result = meas_xxy(nshots=nshots)\n",
    "xxy_result.frequencies()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q0: ─────H─o─H───SDG─H─────M─\n",
      "q1: ─H─o─H─|─SDG─H─────────M─\n",
      "q2: ───X───X─H───S───SDG─H─M─\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({'100': 2607, '111': 2505, '010': 2462, '001': 2426})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meas_yyy = GHZ_3_generate()\n",
    "meas_yyy.add([gates.SDG(i) for i in range(3)])\n",
    "meas_yyy.add([gates.H(i) for i in range(3)])\n",
    "meas_yyy.add(gates.M(0,1,2))\n",
    "print(meas_yyy.draw())\n",
    "yyy_result = meas_yyy(nshots=nshots)\n",
    "yyy_result.frequencies()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_to_frequency(counter, total_shots: int = None):\n",
    "    if total_shots is None:\n",
    "        total_shots = sum(counter.values())\n",
    "    frequencies = {outcome: count / total_shots for outcome, count in counter.items()}\n",
    "    return frequencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      XXXXX   XXXYY\n",
      "000  0.2467  0.0000\n",
      "011  0.2639  0.0000\n",
      "101  0.2472  0.0000\n",
      "110  0.2422  0.0000\n",
      "001  0.0000  0.2426\n",
      "010  0.0000  0.2462\n",
      "100  0.0000  0.2607\n",
      "111  0.0000  0.2505\n"
     ]
    }
   ],
   "source": [
    "xxy_frequency = count_to_frequency(xxy_result.frequencies())\n",
    "yyy_frequency = count_to_frequency(yyy_result.frequencies())\n",
    "data = {\n",
    "    'XXXXX' : dict(xxy_frequency),\n",
    "    'XXXYY' : dict(yyy_frequency),\n",
    "}\n",
    "df = pd.DataFrame(data)\n",
    "df = df.fillna(0)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To translate the frequencies into the expected values, we group the resultant states by parity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_parity(outcome):\n",
    "    \"\"\"Determine the parity of string outcome. 1 if odd, 0 iff even.\"\"\"\n",
    "    return outcome.count('1')%2\n",
    "\n",
    "def calculate_expectancy(frequency_dict):\n",
    "    \"\"\"Calculate the expected value based on parity\"\"\"\n",
    "    expect = 0\n",
    "    for outcome, probability in frequency_dict.items():\n",
    "        if calculate_parity(outcome) == 0: # Even parity\n",
    "            expect += probability\n",
    "        else:\n",
    "            expect -= probability\n",
    "    return expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 -1.0\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "A = calculate_expectancy(xxy_frequency)\n",
    "B = calculate_expectancy(yyy_frequency)\n",
    "print(A,B)\n",
    "M3 = 3*A - B\n",
    "print(M3)"
   ]
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}