E91_ab.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuda is not available!\n",
      "logicqubit version 1.5.6\n"
     ]
    }
   ],
   "source": [
    "from logicqubit.logic import *\n",
    "from math import *\n",
    "import random\n",
    "import operator\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, Math, Latex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_matrix(matrix):\n",
    "    value = sp.latex(sp.Matrix(matrix))\n",
    "    display(Math(value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a3b1': -0.7966101694915254, 'a1b1': -0.7777777777777778, 'a3b3': -0.8148148148148148, 'a1b3': 0.6896551724137931}\n",
      "3.0788579344979112\n"
     ]
    }
   ],
   "source": [
    "# |<C>| = |<a3b1> + <a1b1> + <a3b3> - <a1b3>| <= 2 for classic systems\n",
    "def bell_inequality(A, B):\n",
    "    direction = {\"a3b1\":0, \"a1b1\":0, \"a3b3\":0, \"a1b3\":0}\n",
    "    count = {\"a3b1\":0, \"a1b1\":0, \"a3b3\":0, \"a1b3\":0}\n",
    "    \n",
    "    # Expected values for a3b1, a1b1, a3b3 and a1b3\n",
    "    for a,b in zip(A,B):\n",
    "        if a[0]==\"a3\" and b[0]==\"b1\":\n",
    "            direction[\"a3b1\"] += a[1]*b[1]\n",
    "            count[\"a3b1\"] += 1\n",
    "        elif a[0]==\"a1\" and b[0]==\"b1\":\n",
    "            direction[\"a1b1\"] += a[1]*b[1]\n",
    "            count[\"a1b1\"] += 1\n",
    "        elif a[0]==\"a3\" and b[0]==\"b3\":\n",
    "            direction[\"a3b3\"] += a[1]*b[1]\n",
    "            count[\"a3b3\"] += 1\n",
    "        elif a[0]==\"a1\" and b[0]==\"b3\":\n",
    "            direction[\"a1b3\"] += a[1]*b[1]\n",
    "            count[\"a1b3\"] += 1\n",
    "\n",
    "    direction[\"a3b1\"] /= count[\"a3b1\"]\n",
    "    direction[\"a1b1\"] /= count[\"a1b1\"]\n",
    "    direction[\"a3b3\"] /= count[\"a3b3\"]\n",
    "    direction[\"a1b3\"] /= count[\"a1b3\"]\n",
    "    # Bell inequality value\n",
    "    inequality = direction[\"a3b1\"] + direction[\"a1b1\"] + direction[\"a3b3\"] - direction[\"a1b3\"]\n",
    "    inequality = sqrt(inequality * inequality)\n",
    "    print(direction)\n",
    "    return inequality\n",
    "\n",
    "def measurements(eva=False, attempts=10):\n",
    "    to_minus_one = lambda x: -1 if x == 0 else x\n",
    "    measure_A = []\n",
    "    measure_B = []\n",
    "  \n",
    "    for i in range(attempts):\n",
    "        logicQuBit = LogicQuBit(2)\n",
    "\n",
    "        A = Qubit()\n",
    "        B = Qubit()\n",
    "\n",
    "        # generate entangled state |01>-|10>\n",
    "        A.H()\n",
    "        B.CNOT(A)\n",
    "        B.X()\n",
    "        B.Z()\n",
    "\n",
    "        # Alice choose the measurement\n",
    "        measure_type_A = random.choice([\"a1\", \"a2\", \"a3\"])\n",
    "        if \"a1\" == measure_type_A: # for x\n",
    "            A.H()\n",
    "        elif \"a2\" == measure_type_A:\n",
    "            A.RY(-pi/4)\n",
    "            \n",
    "        # Alice performs the measurement\n",
    "        m_A = logicQuBit.Measure_One(A)[0]\n",
    "        m_A = to_minus_one(m_A)\n",
    "\n",
    "        # Eva performs the measurement\n",
    "        if eva:\n",
    "            measure_type_E = random.choice([\"b1\", \"b2\", \"b3\"])\n",
    "            if \"b1\" == measure_type_E:\n",
    "                B.RY(-pi/4)\n",
    "            elif \"b3\" == measure_type_E:\n",
    "                B.RY(pi/4)\n",
    "            m_E = logicQuBit.Measure_One(B)[0]\n",
    "\n",
    "        # Bob choose the measurement\n",
    "        measure_type_B = random.choice([\"b1\", \"b2\", \"b3\"])\n",
    "        if \"b1\" == measure_type_B:\n",
    "            B.RY(-pi/4)\n",
    "        elif \"b3\" == measure_type_B:\n",
    "            B.RY(pi/4)\n",
    "       \n",
    "        # Bob performs the measurement\n",
    "        m_B = logicQuBit.Measure_One(B)[0]\n",
    "        m_B = to_minus_one(m_B)\n",
    "\n",
    "        measure_A.append([measure_type_A, m_A])\n",
    "        measure_B.append([measure_type_B, m_B])\n",
    "\n",
    "    return measure_A, measure_B\n",
    "\n",
    "measure_A, measure_B = measurements(eva=False, attempts=500)\n",
    "bell = bell_inequality(measure_A, measure_B)\n",
    "print(bell)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perform_measurements(eva = False, attempts=200):\n",
    "    to_plus_one = lambda x: 0 if x == -1 else x\n",
    "\n",
    "    measure_A, measure_B = measurements(eva=eva, attempts=attempts)\n",
    "\n",
    "    # incompatible measures are shared and used to calculate bell inequality\n",
    "    shared_measures_A = []\n",
    "    shared_measures_B = []\n",
    "\n",
    "    # compatible measures will not be shared\n",
    "    unshared_measures_A = [] \n",
    "    unshared_measures_B = []\n",
    "\n",
    "    # shared measures and types of measures are public information\n",
    "    for A,B in zip(measure_A,measure_B):\n",
    "        if (A[0] == 'a3' and B[0] == 'b2') or (A[0] == 'a2' and B[0] == 'b1'):\n",
    "            unshared_measures_A.append(A)\n",
    "            unshared_measures_B.append(B)\n",
    "        else:\n",
    "            shared_measures_A.append(A)\n",
    "            shared_measures_B.append(B)\n",
    "\n",
    "    bell = bell_inequality(shared_measures_A, shared_measures_B)\n",
    "    key_A = None\n",
    "    key_B = None\n",
    "    if bell > 2:\n",
    "        key_A = [to_plus_one(measure[1]) for measure in unshared_measures_A]\n",
    "        key_B = [int(not to_plus_one(measure[1])) for measure in unshared_measures_B]\n",
    "    else:\n",
    "        print(\"untrusted key!\")\n",
    "    return key_A, key_B, bell, zip(unshared_measures_A, unshared_measures_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a3b1': -0.5454545454545454, 'a1b1': -0.8181818181818182, 'a3b3': -0.8333333333333334, 'a1b3': 0.7391304347826086}\n",
      "Bell inequality: 2.9361001317523057\n",
      "[1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0]\n",
      "[1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# without eva\n",
    "key_A, key_B, bell, _ = perform_measurements(eva = False)\n",
    "print(\"Bell inequality: \"+str(bell))\n",
    "print(key_A)\n",
    "print(key_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a3b1': -0.7391304347826086, 'a1b1': 0.18181818181818182, 'a3b3': -0.6666666666666666, 'a1b3': -0.05263157894736842}\n",
      "untrusted key!\n",
      "Bell inequality: 1.171347340683725\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# with eva\n",
    "key_A, key_B, bell, _ = perform_measurements(eva = True)\n",
    "print(\"Bell inequality: \"+str(bell))\n",
    "print(key_A)\n",
    "print(key_B)"
   ]
  },
  {
   "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
}