code_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical implementations of $\\text{SDP}(n_1,n_2)$\n",
    "\n",
    "In this notebook, we would like to implement the semidefinite programmings (SDP) expressed in Eq.(15) in the paper https://arxiv.org/abs/2005.08883."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "import math\n",
    "import functools as fc\n",
    "from operator import mul\n",
    "\n",
    "import lib_non_local_games as nlg\n",
    "import SDP_hierarchy as SDP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if Mosek is installed on the machine,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not 'MOSEK' in cp.installed_solvers():\n",
    "    raise RuntimeError('Please install MOSEK before running this notebook.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we briefly mentioned in the paper, it is better to explicitly exploit the classical structure of the optimisation variable $\\rho_{(A_1Q_1T)^{n_1}(A_2Q_2\\hat{T})^{n_2}(S\\hat{S})}$ for real implementations as it could reduce the size of the program significantly. For simplicity, we will denote $a_1, a_2$ as $a,b$ and $q_1,q_2$ as $x,y$ in this code. Then, the optimisation variable can be expressed as\n",
    "\n",
    "$$\\rho_{(A_1Q_1T)^{n_1}(A_2Q_2\\hat{T})^{n_2}(S\\hat{S})} = \\sum_{a^{n_1},b^{n_2},x^{n_1},y^{n_2}} \\vert a^{n_1},b^{n_2},x^{n_1},y^{n_2}\\rangle\\langle a^{n_1},b^{n_2},x^{n_1},y^{n_2}\\vert \\otimes \\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2}),$$\n",
    "\n",
    "and the SDPs in Eq.(15) can be rewritten with the classical structure as\n",
    "\n",
    "$$ \\mbox{sdp}_{n_1,n_2} (V,\\pi,T) = |T|^2 \\max_{\\rho} \\sum_{a,b,x,y} V(a,b,x,y) \\, \\mbox{tr}\\left[\\Phi_{T\\hat{T}|S\\hat{S}} \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]$$\n",
    "$$s.t. \\quad \\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2}) \\geq 0 \\quad \\forall a^{n_1},b^{n_2},x^{n_1},y^{n_2}\\,, \\quad \\sum_{a^{n_1},b^{n_2},x^{n_1},y^{n_2}} \\mbox{tr}\\left[\\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2})\\right]=1$$\n",
    "$$\\mbox{permutation invariance on }a^{n_1},x^{n_1}\\mbox{ and the system }T^{n_1}\\mbox{ with respect to the other systems}$$\n",
    "$$\\mbox{permutation invariance on }b^{n_2},y^{n_2}\\mbox{ and the system }\\hat{T}^{n_2}\\mbox{ with respect to the other systems}$$\n",
    "$$\\sum_{a}\\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2}) = \\left(\\pi(x)\\frac{I_T}{|T|}\\right)\\otimes \\rho_{T^{n_1-1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1-1},b^{n_2},x^{n_1-1},y^{n_2})$$\n",
    "$$\\sum_{b}\\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2}) = \\left(\\pi(y)\\frac{I_{\\hat{T}}}{|T|}\\right)\\otimes \\rho_{T^{n_1}\\hat{T}^{n_2-1}S\\hat{S}}(a^{n_1},b^{n_2-1},x^{n_1},y^{n_2-1})$$\n",
    "$$\\rho^{T_{(T^{n_1})}}_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2})\\geq0\\,, \\quad \\rho^{T_{(\\hat{T}^{n_2})}}_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2})\\geq0\\,, \\quad \\rho^{T_{(S\\hat{S})}}_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2})\\geq0, \\cdots$$\n",
    "\n",
    "We will firstly demonstrate the implementations of the first few levels with the CHSH game, and then show the numerical examples we described in Section 2 of the paper: the rule matrix $W$ and $I_{3322}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CHSH game\n",
    "\n",
    "Parameters of the game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cardinality of Alice and Bob's set of answers\n",
    "answers = (2,2)\n",
    "\n",
    "# Cardinality of Alice and Bob's set of questions\n",
    "questions = (2,2)\n",
    "\n",
    "# Dimension of the assisting quantum system\n",
    "dim_assistance = 2\n",
    "\n",
    "# Rule function of the game\n",
    "rule_function = nlg.CHSH_rule_function_A1Q1A2Q2\n",
    "\n",
    "# Probability distribution of the game\n",
    "probQ1 = (1/2,1/2)\n",
    "probQ2 = (1/2,1/2)\n",
    "distributions = [probQ1,probQ2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear programming ($|T|=1$)\n",
    "\n",
    "In this case, Alice and Bob do not have access to an assisting quantum system, and the problem boils down to the classical one. \n",
    "\n",
    "Each block $\\rho_{T^{n_1}\\hat{T}^{n_2}S\\hat{S}}(a^{n_1},b^{n_2},x^{n_1},y^{n_2})$ in the optimisation variable becomes a number depending on $a^{n_1},b^{n_2},x^{n_1},y^{n_2}$. This means that the whole variable becomes an extendible classical probability distribution $p(a^{n_1},b^{n_2},x^{n_1},y^{n_2})$, and the SDPs become linear programmings (LP).\n",
    "\n",
    "Since it is enough to extend only one part in the classical case, we can simplify the SDP hierarchy for $|T|=1$ as\n",
    "$$\\mbox{lp}_n (V,\\pi,1) = \\max_{p} \\sum_{a,b,x,y} V(a,b,x,y) \\, p(a,b,x,y)$$\n",
    "$$s.t. \\quad p(a,b^n,x,y^n) \\geq 0 \\quad \\forall a,b^n,x,y^n\\,, \\quad \\sum_{a,b^n,x,y^n} p(a,b^n,x,y^n)=1$$\n",
    "$$\\mbox{permutation invariance on }b^{n},y^{n}\\mbox{ with respect to } a,x$$\n",
    "$$\\sum_{a}p(a,b^n,x,y^n) = \\pi(x)\\,p(b^n,y^n)$$\n",
    "$$\\sum_{b}p(a,b^n,x,y^n) = \\pi(y)\\,p(a,b^{n-1},x,y^{n-1})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cardinality of answer/question sets for Alice\n",
    "subs_A1Q1 = (answers[0], questions[0])\n",
    "\n",
    "# Cardinality of answer/question sets for Bob\n",
    "subs_A2Q2 = (answers[1], questions[0])\n",
    "\n",
    "# This function solves the LP for the CHSH game with no quantum assistance\n",
    "#\n",
    "def CHSH_classical(rule_function,subs_A1Q1,subs_A2Q2,probQ1,probQ2,level=1):\n",
    "    \n",
    "    ## CLASSICAL CONSTRAINTS\n",
    "    constraints = []\n",
    "    classical_prob, BtI_ext = nlg.classical_constraints(constraints,subs_A1Q1,subs_A2Q2,probQ1,probQ2,level)\n",
    "    \n",
    "    ## OBJECTIVE FUNCTION\n",
    "    indices_A1Q1A2Q2 = nlg.indices_list(subs_A1Q1+subs_A2Q2)\n",
    "    indices_A2Q2_ext_but_one = nlg.indices_list(subs_A2Q2*(level-1))\n",
    "    \n",
    "    object_function = 0\n",
    "    \n",
    "    # The object function is\n",
    "    for index_A1Q1A2Q2 in indices_A1Q1A2Q2:\n",
    "        indices_a1q1a2q2_ext = nlg.fuse_arrays(np.array([index_A1Q1A2Q2]),indices_A2Q2_ext_but_one)\n",
    "        object_function += rule_function(*index_A1Q1A2Q2) * sum([classical_prob[BtI_ext(i)] for i in indices_a1q1a2q2_ext])\n",
    "    \n",
    "    ## PROBLEM\n",
    "    prob = cp.Problem(cp.Maximize(object_function), constraints)\n",
    "    result = prob.solve(solver='MOSEK')\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first level (= the non-signalling value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0000000010619423"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHSH_classical(rule_function,subs_A1Q1,subs_A2Q2,probQ1,probQ2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7500000000123522"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHSH_classical(rule_function,subs_A1Q1,subs_A2Q2,probQ1,probQ2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7500000000056621"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHSH_classical(rule_function,subs_A1Q1,subs_A2Q2,probQ1,probQ2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The forth level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75000000130713"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHSH_classical(rule_function,subs_A1Q1,subs_A2Q2,probQ1,probQ2,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SDP(1,1)\n",
    "\n",
    "$\\mbox{sdp}_{1,1}$ can be explicitly written as\n",
    "$$ \\mbox{sdp}_{1,1} (V,\\pi,T) = |T|^2 \\max_{\\rho} \\sum_{a,b,x,y} V(a,b,x,y) \\, \\mbox{tr}\\left[\\Phi_{T\\hat{T}|S\\hat{S}} \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]$$\n",
    "$$\\text{such that} \\quad \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y) \\geq 0 \\quad \\forall a,b,x,y\\,, \\quad \\sum_{a,b,x,y} \\mbox{tr}\\left[\\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]=1$$\n",
    "$$\\sum_{a}\\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y) = \\left(\\pi(x)\\frac{I_{T}}{|T|}\\right)\\otimes \\rho_{\\hat{T}S\\hat{S}}(b,y)$$\n",
    "$$\\sum_{b}\\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y) = \\left(\\pi(y)\\frac{I_{\\hat{T}}}{|T|}\\right)\\otimes \\rho_{TS\\hat{S}}(a,x)$$\n",
    "$$\\rho^{T_{T}}_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\geq0\\,, \\quad \\rho^{T_{\\hat{T}}}_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\geq0\\,, \\quad \\rho^{T_{S\\hat{S}}}_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\geq0.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# SDP level (n1,n2)\n",
    "level = (1,1)\n",
    "\n",
    "# Create the SDP relaxation\n",
    "CHSH = SDP.SDP_relaxation(level, answers, questions, dim_assistance, rule_function, distributions)\n",
    "\n",
    "# Create the variable of the problem\n",
    "CHSH.initialize_variable()\n",
    "\n",
    "# Create the objective function based on the rule function passed\n",
    "CHSH.create_objective_function()\n",
    "\n",
    "# Create the constraints\n",
    "CHSH.state_constraint()\n",
    "CHSH.full_permutation_constraints()\n",
    "CHSH.linear_constraint_Alice()\n",
    "CHSH.linear_constraint_Bob()\n",
    "CHSH.PPT_constraints()\n",
    "CHSH.NPA1_constraint()\n",
    "\n",
    "# Create the problem and solve it\n",
    "prob = CHSH.write_problem()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions\n",
    "\n",
    "SDP(1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0000000001446023\n"
     ]
    }
   ],
   "source": [
    "SDP11 = prob.solve(solver='MOSEK',verbose=False)\n",
    "print(SDP11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(1,1) + PPT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0000000001136375\n"
     ]
    }
   ],
   "source": [
    "SDP11_PPT = prob.solve(solver='MOSEK',verbose=False)\n",
    "print(SDP11_PPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(1,1) + PPT + NPA1 (with the projective assumption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8535533905976226\n"
     ]
    }
   ],
   "source": [
    "SDP11_PPT_NPA1proj = prob.solve(solver='MOSEK',verbose=False)\n",
    "print(SDP11_PPT_NPA1proj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(1,1) + PPT + NPA1 (without the projective assumption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8535533905972075\n"
     ]
    }
   ],
   "source": [
    "SDP11_PPT_NPA1 = prob.solve(solver='MOSEK',verbose=False)\n",
    "print(SDP11_PPT_NPA1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(1,1) + PPT + The projective measurement assumption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8535533907161744\n"
     ]
    }
   ],
   "source": [
    "SDP11_PPT_proj = prob11.solve(verbose=False,solver='MOSEK')\n",
    "print(SDP11_PPT_proj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SDP(2,1)\n",
    "\n",
    "$\\mbox{sdp}_{2,1}$ can be explicitly written as\n",
    "$$ \\mbox{sdp}_{2,1} (V,\\pi,T) = |T|^2 \\max_{\\rho} \\sum_{a,b,x,y} V(a,b,x,y) \\, \\mbox{tr}\\left[\\Phi_{T\\hat{T}|S\\hat{S}} \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]$$\n",
    "$$\\text{such that} \\quad \\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y) \\geq 0 \\quad \\forall a_1,a_2,b,x_1,x_2,y\\,, \\quad \\sum_{a_1,a_2,b,x_1,x_2,y} \\mbox{tr}\\left[\\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y)\\right]=1$$\n",
    "$$\\left(F_{T_1|T_2}\\otimes I_{\\hat{T}S\\hat{S}}\\right) \\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_2,a_1,b,x_2,x_1,y) \\left(F_{T_1|T_2}\\otimes I_{\\hat{T}S\\hat{S}}\\right) = \\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y)$$\n",
    "$$\\sum_{a_1}\\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y) = \\left(\\pi(x_1)\\frac{I_{T_1}}{|T|}\\right)\\otimes \\rho_{T_2\\hat{T}S\\hat{S}}(a_2,b,x_2,y)$$\n",
    "$$\\sum_{b}\\rho_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y) = \\left(\\pi(y)\\frac{I_{\\hat{T}}}{|T|}\\right)\\otimes \\rho_{T_1T_2S\\hat{S}}(a_1,a_2,x_1,x_2)$$\n",
    "$$\\rho^{T_{T_1T_2}}_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y)\\geq0\\,, \\quad \\rho^{T_{\\hat{T}}}_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y)\\geq0\\,, \\quad \\rho^{T_{S\\hat{S}}}_{T_1T_2\\hat{T}S\\hat{S}}(a_1,a_2,b,x_1,x_2,y)\\geq0\\,, \\quad \\ldots$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SDP level (n1,n2)\n",
    "level = (2,1)\n",
    "\n",
    "# Create the SDP relaxation\n",
    "CHSH = SDP.SDP_relaxation(level, answers, questions, dim_assistance, rule_function, distributions)\n",
    "\n",
    "# Create the variable of the problem\n",
    "CHSH.initialize_variable()\n",
    "\n",
    "# Create the objective function based on the rule function passed\n",
    "CHSH.create_objective_function()\n",
    "\n",
    "# Create the constraints\n",
    "CHSH.state_constraint()\n",
    "CHSH.full_permutation_constraints()\n",
    "CHSH.linear_constraint_Alice()\n",
    "CHSH.linear_constraint_Bob()\n",
    "CHSH.PPT_constraints()\n",
    "CHSH.NPA1_constraint()\n",
    "\n",
    "# Create the problem and solve it\n",
    "prob = CHSH.write_problem()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions\n",
    "\n",
    "SDP(2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8943377920088351\n"
     ]
    }
   ],
   "source": [
    "SDP21 = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(2,1) + PPT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8750000000397471\n"
     ]
    }
   ],
   "source": [
    "SDP21_PPT = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP21_PPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(2,1) + PPT + NPA1 (with the projective assumption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.853553390752552\n"
     ]
    }
   ],
   "source": [
    "SDP21_PPT_NPA1proj = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP21_PPT_NPA1proj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(2,1) + PPT + NPA1 (without the projective assumption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8535533905983419\n"
     ]
    }
   ],
   "source": [
    "SDP21_PPT_NPA1 = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP21_PPT_NPA1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SDP(2,2)\n",
    "\n",
    "$\\mbox{sdp}_{2,2}$ can be explicitly written as\n",
    "$$ \\mbox{sdp}_{2,2} (V,\\pi,T) = |T|^2 \\max_{\\rho} \\sum_{a,b,x,y} V(a,b,x,y) \\, \\mbox{tr}\\left[\\Phi_{T\\hat{T}|S\\hat{S}} \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]$$\n",
    "$$\\text{such that} \\quad \\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2) \\geq 0 \\quad \\forall a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2$$ $$\\sum_{a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2} \\mbox{tr}\\left[\\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)\\right]=1$$\n",
    "$$\\left(F_{T_1|T_2}\\otimes I_{\\hat{T}_1\\hat{T}_2S\\hat{S}}\\right) \\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_2,a_1,b_1,b_2,x_2,x_1,y_1,y_2) \\left(F_{T_1|T_2}\\otimes I_{\\hat{T}_1\\hat{T}_2S\\hat{S}}\\right) = \\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)$$\n",
    "$$\\left(F_{\\hat{T}_1|\\hat{T}_2}\\otimes I_{T_1T_2S\\hat{S}}\\right) \\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_2,b_1,x_1,x_2,y_2,y_1) \\left(F_{\\hat{T}_1|\\hat{T}_2}\\otimes I_{T_1T_2S\\hat{S}}\\right) = \\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)$$\n",
    "$$\\sum_{a_1}\\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2) = \\left(\\pi(x_1)\\frac{I_{T_1}}{|T|}\\right)\\otimes \\rho_{T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_2,b_1,b_2,x_2,y_1,y_2)$$\n",
    "$$\\sum_{b_1}\\rho_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2) = \\left(\\pi(y_1)\\frac{I_{\\hat{T}_1}}{|T|}\\right)\\otimes \\rho_{T_1T_2\\hat{T}_2S\\hat{S}}(a_1,a_2,b_2,x_1,x_2,y_2)$$\n",
    "$$\\rho^{T_{T_1T_2}}_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)\\geq0\\,, \\quad \\rho^{T_{\\hat{T}_1\\hat{T}_2}}_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)\\geq0\\, \\quad \\rho^{T_{S\\hat{S}}}_{T_1T_2\\hat{T}_1\\hat{T}_2S\\hat{S}}(a_1,a_2,b_1,b_2,x_1,x_2,y_1,y_2)\\geq0\\,, \\quad \\ldots$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SDP level (n1,n2)\n",
    "level = (2,2)\n",
    "\n",
    "# Create the SDP relaxation\n",
    "CHSH = SDP.SDP_relaxation(level, answers, questions, dim_assistance, rule_function, distributions)\n",
    "\n",
    "# Create the variable of the problem\n",
    "CHSH.initialize_variable()\n",
    "\n",
    "# Create the objective function based on the rule function passed\n",
    "CHSH.create_objective_function()\n",
    "\n",
    "# Create the constraints\n",
    "CHSH.state_constraint()\n",
    "CHSH.full_permutation_constraints()\n",
    "CHSH.linear_constraint_Alice()\n",
    "CHSH.linear_constraint_Bob()\n",
    "CHSH.PPT_constraints()\n",
    "CHSH.NPA1_constraint()\n",
    "\n",
    "# Create the problem and solve it\n",
    "prob = CHSH.write_problem()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions\n",
    "\n",
    "SDP(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SDP22 = prob.solve(verbose=False, solver='MOSEK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP22 = 0.87976264596\n",
    "\n",
    "The top memory requirement was 229Gb."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "=================================================================\n",
    "\n",
    "From here, even a 500gb RAM computer was not enough."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SDP22_PPT = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP22)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SDP(3,1)\n",
    "\n",
    "$\\mbox{sdp}_{3,1}$ can be written explicitly as\n",
    "$$ \\mbox{sdp}_{3,1} (V,\\pi,T) = |T|^2 \\max_{\\rho} \\sum_{a,b,x,y} V(a,b,x,y) \\, \\mbox{tr}\\left[\\Phi_{T\\hat{T}|S\\hat{S}} \\rho_{T\\hat{T}S\\hat{S}}(a,b,x,y)\\right]$$\n",
    "$$\\text{such that} \\quad \\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y) \\geq 0 \\quad \\forall a_1,a_2,a_3,b,x_1,x_2,x_3,y$$ $$ \\sum_{a_1,a_2,a_3,b,x_1,x_2,x_3,y} \\mbox{tr}\\left[\\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)\\right]=1$$\n",
    "$$\\left(F_{T_1|T_2}\\otimes I_{T_3\\hat{T}S\\hat{S}}\\right) \\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_2,a_1,a_3,b,x_2,x_1,x_3,y) \\left(F_{T_1|T_2}\\otimes I_{T_3\\hat{T}S\\hat{S}}\\right) = \\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)$$\n",
    "$$\\left(F_{T_2|T_3}\\otimes I_{T_1\\hat{T}S\\hat{S}}\\right) \\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_3,a_2,b,x_1,x_3,x_2,y) \\left(F_{T_2|T_3}\\otimes I_{T_1\\hat{T}S\\hat{S}}\\right) = \\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)$$\n",
    "$$\\sum_{a_1}\\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y) = \\left(\\pi(x_1)\\frac{I_{T_1}}{|T|}\\right)\\otimes \\rho_{T_2T_3\\hat{T}S\\hat{S}}(a_2,a_3,b,x_2,x_3,y)$$\n",
    "$$\\sum_{b}\\rho_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y) = \\left(\\pi(y)\\frac{I_{\\hat{T}}}{|T|}\\right)\\otimes \\rho_{T_1T_2T_3S\\hat{S}}(a_1,a_2,a_3,x_1,x_2,x_3)$$\n",
    "$$\\rho^{T_{T_1T_2T_3}}_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)\\geq0\\,, \\quad \\rho^{T_{\\hat{T}}}_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)\\geq0\\,, \\quad \\rho^{T_{S\\hat{S}}}_{T_1T_2T_3\\hat{T}S\\hat{S}}(a_1,a_2,a_3,b,x_1,x_2,x_3,y)\\geq0\\,, \\quad \\ldots$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SDP level (n1,n2)\n",
    "level = (3,1)\n",
    "\n",
    "# Create the SDP relaxation\n",
    "CHSH = SDP.SDP_relaxation(level, answers, questions, dim_assistance, rule_function, distributions)\n",
    "\n",
    "# Create the variable of the problem\n",
    "CHSH.initialize_variable()\n",
    "\n",
    "# Create the objective function based on the rule function passed\n",
    "CHSH.create_objective_function()\n",
    "\n",
    "# Create the constraints\n",
    "CHSH.state_constraint()\n",
    "CHSH.full_permutation_constraints()\n",
    "CHSH.linear_constraint_Alice()\n",
    "CHSH.linear_constraint_Bob()\n",
    "CHSH.PPT_constraints()\n",
    "CHSH.NPA1_constraint()\n",
    "\n",
    "# Create the problem and solve it\n",
    "prob = CHSH.write_problem()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions\n",
    "\n",
    "SDP(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SDP31 = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP31 = 0.87227925863\n",
    "\n",
    "The highest memory requirement was 300Gb."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "=================================================================\n",
    "\n",
    "From here, even a 500gb RAM computer was not enough."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SDP31_PPT = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDP31_PPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# $I_{3322}$ game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the dimensions of the game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "dimA1 = 2\n",
    "dimA2 = 2\n",
    "dimQ1 = 3\n",
    "dimQ2 = 3\n",
    "\n",
    "dimT = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inputs of the program\n",
    "\n",
    "- $V(a_1,a_2,q_1,q_2)$: I3322 rule function\n",
    "- $\\pi(q1,q2)$: the uniform distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "probQ1 = (1/3,1/3,1/3)\n",
    "probQ2 = (1/3,1/3,1/3)\n",
    "\n",
    "rule_function = lambda a,x,b,y : nlg.general_I3322_rule_ineq(a,x,b,y,probQ1,probQ2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\text{SDP}^{\\text{proj}}(3,3)$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We make use of the results in Appendix F of https://arxiv.org/abs/2005.08883 to simplify our SDP. This simplified form holds when Alice and Bob are restricted to rank-1 projective measurement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subsystems A1 Q1 A2 Q2\n",
    "subs_A1Q1A2Q2 = (dimA1,dimQ1,dimA2,dimQ2)\n",
    "indices_A1Q1A2Q2 = nlg.indices_list(subs_A1Q1A2Q2)\n",
    "dim_A1Q1A2Q2 = fc.reduce(mul, subs_A1Q1A2Q2, 1)\n",
    "\n",
    "# Subsystems T_q1=1 ... T_q1=|Q1| T_q2=1 ... T_q2=|Q2|\n",
    "subs_W = tuple(np.full(dimQ1+dimQ2, dimT))\n",
    "dim_W = fc.reduce(mul, subs_W, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "## VARIABLE\n",
    "W = cp.Variable((dim_W,dim_W),symmetric=True)\n",
    "\n",
    "## OBJECTIVE FUNCTION\n",
    "\n",
    "# Build the operator connected to the inequality I\n",
    "I_operator = nlg.I_operator(rule_function,indices_A1Q1A2Q2,dimQ1,dimQ2,dimT)\n",
    "\n",
    "# Objective function\n",
    "objective_function = cp.trace(cp.matmul(W,I_operator))\n",
    "    \n",
    "## CONSTRAINTS\n",
    "constraints = []\n",
    "    \n",
    "# 1) rho_TTSS are (sub-normalized) quantum states\n",
    "# 1a) trace of the sum is 1\n",
    "constraints.append( cp.trace(W) - 1 == 0 )\n",
    "\n",
    "# 1b) positive semidefinite matrices\n",
    "constraints.append( W >> 0 )\n",
    "\n",
    "# 2) PPT\n",
    "PPT_dim = (2,)*(dimQ1+dimQ2-1)\n",
    "PPT_list = [np.concatenate((np.full(2,item[0]),item[1:])) for item in nlg.indices_list(PPT_dim)]\n",
    "\n",
    "for PPT in PPT_list:\n",
    "    \n",
    "    if (sum(PPT) == 0) or (sum(PPT) == 6):\n",
    "        continue\n",
    "    \n",
    "    constraints.append( nlg.partial_transpose(W,subs_W,tuple(PPT)) >> 0 )\n",
    "\n",
    "# Write the problem\n",
    "prob = cp.Problem(cp.Maximize(objective_function), constraints)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SDP(3,3) with projective assumption (only PPT constraints are imposed). This runs on a laptop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Problem\n",
      "  Name                   :                 \n",
      "  Objective sense        : min             \n",
      "  Type                   : CONIC (conic optimization problem)\n",
      "  Constraints            : 126977          \n",
      "  Cones                  : 0               \n",
      "  Scalar variables       : 2080            \n",
      "  Matrix variables       : 31              \n",
      "  Integer variables      : 0               \n",
      "\n",
      "Optimizer started.\n",
      "Problem\n",
      "  Name                   :                 \n",
      "  Objective sense        : min             \n",
      "  Type                   : CONIC (conic optimization problem)\n",
      "  Constraints            : 126977          \n",
      "  Cones                  : 0               \n",
      "  Scalar variables       : 2080            \n",
      "  Matrix variables       : 31              \n",
      "  Integer variables      : 0               \n",
      "\n",
      "Optimizer  - threads                : 4               \n",
      "Optimizer  - solved problem         : the primal      \n",
      "Optimizer  - Constraints            : 126977\n",
      "Optimizer  - Cones                  : 1\n",
      "Optimizer  - Scalar variables       : 2081              conic                  : 2081            \n",
      "Optimizer  - Semi-definite variables: 31                scalarized             : 64480           \n",
      "Factor     - setup time             : 404.52            dense det. time        : 54.55           \n",
      "Factor     - ML order time          : 202.41            GP order time          : 0.00            \n",
      "Factor     - nonzeros before factor : 2.60e+08          after factor           : 4.42e+08        \n",
      "Factor     - dense dim.             : 2082              flops                  : 1.63e+12        \n",
      "ITE PFEAS    DFEAS    GFEAS    PRSTATUS   POBJ              DOBJ              MU       TIME  \n",
      "0   1.0e+00  4.0e+00  1.0e+00  0.00e+00   0.000000000e+00   0.000000000e+00   1.0e+00  404.81\n",
      "1   4.1e-01  1.6e+00  2.9e-01  6.04e+00   -2.548134370e+00  -2.128599872e+00  4.1e-01  464.05\n",
      "2   1.2e-01  4.7e-01  2.9e-02  3.24e+00   -5.546652408e-01  -5.021746536e-01  1.2e-01  534.91\n",
      "3   1.6e-02  6.6e-02  2.7e-04  1.50e+00   -2.717696114e-01  -2.724578806e-01  1.6e-02  609.42\n",
      "4   9.9e-03  3.9e-02  1.2e-04  1.06e+00   -2.659661952e-01  -2.663922382e-01  9.9e-03  680.44\n",
      "5   5.0e-04  2.0e-03  8.3e-07  1.04e+00   -2.514055309e-01  -2.514308311e-01  5.0e-04  751.13\n",
      "6   5.8e-05  2.3e-04  2.4e-08  1.00e+00   -2.501294778e-01  -2.501325873e-01  5.8e-05  821.76\n",
      "7   2.4e-06  9.7e-06  1.9e-10  1.00e+00   -2.500047746e-01  -2.500049060e-01  2.4e-06  892.20\n",
      "8   1.0e-07  5.3e-07  1.6e-12  1.00e+00   -2.500002096e-01  -2.500002151e-01  1.0e-07  965.03\n",
      "Optimizer terminated. Time: 966.00  \n",
      "\n",
      "\n",
      "Interior-point solution summary\n",
      "  Problem status  : PRIMAL_AND_DUAL_FEASIBLE\n",
      "  Solution status : OPTIMAL\n",
      "  Primal.  obj: -2.5000003972e-01   nrm: 1e+00    Viol.  con: 1e-09    var: 0e+00    barvar: 0e+00  \n",
      "  Dual.    obj: -2.5000004065e-01   nrm: 4e-01    Viol.  con: 0e+00    var: 4e-09    barvar: 1e-09  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.25000003971793644"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob.solve(verbose=True, solver='MOSEK')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The rule matrix W in Table 1 (arXiv:2005.08883)\n",
    "\n",
    "This is one example of our SDPs beating the first level NPA values. We could beat the first level NPA value for the rule matrix W [Table 1, arXiv:2005.08883] with SDP(2,1) + PPT + NPA1(without the projective assumption). The parameters of the game are,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cardinality of Alice and Bob's set of answers\n",
    "answers = (3,3)\n",
    "\n",
    "# Cardinality of Alice and Bob's set of questions\n",
    "questions = (2,2)\n",
    "\n",
    "# Dimension of the assisting quantum system\n",
    "dim_assistance = 2\n",
    "\n",
    "# Rule function of the game\n",
    "rule_matrix = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0]\n",
    "subsys = (3,2,3,2)\n",
    "rule_function = nlg.generate_rule_function_from_array(rule_matrix,subsys)\n",
    "\n",
    "# Probability distribution of the game\n",
    "probQ1 = (1/2,1/2)\n",
    "probQ2 = (1/2,1/2)\n",
    "distributions = [probQ1,probQ2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SDP(2,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SDP level (n1,n2)\n",
    "level = (2,1)\n",
    "\n",
    "# Create the SDP relaxation\n",
    "Wgame = SDP.SDP_relaxation(level, answers, questions, dim_assistance, rule_function, distributions)\n",
    "\n",
    "# Create the variable of the problem\n",
    "Wgame.initialize_variable()\n",
    "\n",
    "# Create the objective function based on the rule function passed\n",
    "Wgame.create_objective_function()\n",
    "\n",
    "# Create the constraints\n",
    "Wgame.state_constraint()\n",
    "Wgame.full_permutation_constraints()\n",
    "Wgame.linear_constraint_Alice()\n",
    "Wgame.linear_constraint_Bob()\n",
    "Wgame.PPT_constraints()\n",
    "\n",
    "# Since |A|=3 and the assisting system is a qubits, we cannot assume projective measurement.\n",
    "Wgame.NPA1_constraint(proj=False)\n",
    "\n",
    "# Create the problem and solve it\n",
    "prob = Wgame.write_problem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SDPW_PPT_NPA1 = prob.solve(verbose=False, solver='MOSEK')\n",
    "print(SDPW_PPT_NPA1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "0.7982567784210112"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is strictly smaller than the first level NPA value 0.8015682753138356, i.e. $\\mbox{sdp}^{\\mbox{NPA1}}_{2,1}(W,\\pi,2) = 0.7982567784210112 < \\mbox{NPA1}(W,\\pi)=0.8015682753138356$"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}