post-quantum-steering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A formalism for steering with local quantum measurements\n",
    "## A. B. Sainz, L. Aolita, M. Piani, M. J. Hoban, P. Skrzypczyk\n",
    "### https://arxiv.org/abs/1708.00756"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook provides details for the numerical results reported in this work\n",
    "\n",
    "If you wish to run the notebook, rather than just view it, you will need:\n",
    "\n",
    "- Matlab with the [API for Python](https://www.mathworks.com/help/matlab/matlab-engine-for-python.html) installed.\n",
    "- The [Calysto Matlab kernel for Python](https://github.com/Calysto/matlab_kernel) \n",
    "- [CVX](http://cvxr.com/) Software for Disciplined Convex Programming \n",
    "- [QETlab](http://www.qetlab.com/Main_Page) a MATLAB toolbook for quantum entanglement.\n",
    "- The codes provided in this the github repository (which are generated by running the notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preliminary function definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate assemblage given state and measurements:\n",
    "\n",
    "We assume that all measurements are dichotomic in the following, and use the \"Collins-Gisin\" (CG) representation of an assemblage -- i.e. we use the no-signalling constraints to give a minimal representation of an assemblage. In particular, we only need to give  \n",
    "\n",
    "\\begin{align}\n",
    "\\sigma_R &= \\mathrm{tr}_{AB}[\\rho^{ABC}] \\\\\n",
    "\\sigma^A_x &= \\mathrm{tr}_{AB}[(M_{0|x} \\otimes \\mathbb{1} \\otimes \\mathbb{1})\\rho^{ABC}] \\quad \\forall x\\\\\n",
    "\\sigma^B_y &= \\mathrm{tr}_{AB}[(\\mathbb{1} \\otimes M_{0|y} \\otimes \\mathbb{1})\\rho^{ABC}] \\quad \\forall x\\\\\n",
    "\\sigma_{xy} &= \\mathrm{tr}_{AB}[(M_{0|x} \\otimes M_{0|y} \\otimes \\mathbb{I})\\rho^{ABC}] \\quad \\forall x,y\n",
    "\\end{align}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file GenerateAssem.m\n",
    "\n",
    "function [Sr,Sx,Sy,S] = GenerateAssem(rho, Ma, Mb)\n",
    "% Given the measurements Ma for Alice, Mb for Bob, and the state rho for\n",
    "% Alice-Bob-Charlie, generates the assemblage for Charlie in CG form\n",
    "\n",
    "    [da,~,ma] = size(Ma);\n",
    "    [db,~,mb] = size(Mb);\n",
    "    dtot=size(rho,1);\n",
    "    dc=dtot/(da*db);\n",
    "    \n",
    "    Sr = PartialTrace(rho,[1,2],[da,db,dc]);\n",
    "    \n",
    "    Sx=zeros(dc,dc,ma);\n",
    "    for x=1:ma\n",
    "        Sx(:,:,x)=PartialTrace(Tensor(Ma(:,:,x),eye(db),eye(dc))*rho,[1,2],[da,db,dc]);\n",
    "    end\n",
    "\n",
    "    Sy=zeros(dc,dc,mb);\n",
    "    for y=1:mb\n",
    "        Sy(:,:,y)=PartialTrace(Tensor(eye(da),Mb(:,:,y),eye(dc))*rho,[1,2],[da,db,dc]);\n",
    "    end\n",
    "    \n",
    "    S=zeros(dc,dc,ma*mb);\n",
    "    for x=1:ma\n",
    "        for y=1:mb\n",
    "            S(:,:,ma*(y-1)+x)=PartialTrace(Tensor(Ma(:,:,x),Mb(:,:,y),eye(dc))*rho,[1,2],[da,db,dc]);\n",
    "        end\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply the Breur-map to an assemblage\n",
    "\n",
    "We want to be able to apply the positive but not completely-positive [Breuer map](https://doi.org/10.1103/PhysRevLett.97.080501) $\\Lambda[\\cdot]$, to an assemblage, where  \n",
    "\n",
    "$$ \\Lambda[\\rho] = \\tfrac{1}{2}(\\mathrm{tr}[\\rho]\\mathbb{I} - \\rho - U\\rho^\\intercal U^\\dagger)$$\n",
    "\n",
    "acts on states in $\\mathbb{C}^4$ and $U$ is an anti-symmetric operator. \n",
    "\n",
    "When applied to an assemblage in CG representation, we have \n",
    "\\begin{align}\n",
    "\\sigma_R' &= \\Lambda[\\sigma_R]\\\\\n",
    "\\sigma_x^{A'} &= \\Lambda[\\sigma_x^A] \\quad \\forall x \\\\\n",
    "\\sigma_y^{B'} &= \\Lambda[\\sigma_y^B] \\quad \\forall y \\\\\n",
    "\\sigma_{xy}' &= \\Lambda[\\sigma_{xy}] \\quad \\forall x,y\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file BreuerMapOnAssem.m\n",
    "\n",
    "function [Rr, Rx, Ry, R] = BreuerMapOnAssem(U, Sr, Sx, Sy,S,ma,mb)\n",
    "% Given an antisymmetric unitary U, it applies the map\n",
    "% Lambda[rho] = 1/2*(trace(rho) Id - rho - U rho' U') \n",
    "% to the assemblage to generate a new one. We are assuming a steering \n",
    "% scenario with two unstrusted parties, Alice and Bob,  ma/mb = no. \n",
    "% of measurements for Alice/Bob and the assemblage is given in CG form\n",
    "\n",
    "    dc=size(Sr,1);\n",
    "    Id=eye(dc);\n",
    "    \n",
    "    Rr=(trace(Sr)*Id-Sr-U*transpose(Sr)*U')/2;\n",
    "    \n",
    "    Rx=zeros(dc,dc,ma);\n",
    "    for x=1:ma\n",
    "        Rx(:,:,x)=(trace(Sx(:,:,x))*Id-Sx(:,:,x)-U*transpose(Sx(:,:,x))*U')/2;\n",
    "    end\n",
    "   \n",
    "    Ry=zeros(dc,dc,mb);\n",
    "    for y=1:mb\n",
    "        Ry(:,:,y)=(trace(Sy(:,:,y))*Id-Sy(:,:,y)-U*transpose(Sy(:,:,y))*U')/2;\n",
    "    end\n",
    "    \n",
    "    R=zeros(dc,dc,ma*mb);\n",
    "    for x=1:ma\n",
    "        for y=1:mb\n",
    "            R(:,:,ma*(y-1)+x)=(trace(S(:,:,ma*(y-1)+x))*Id-S(:,:,ma*(y-1)+x)-U*transpose(S(:,:,ma*(y-1)+x))*U')/2;\n",
    "        end\n",
    "    end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outer approximation to the set of quantum assemblages\n",
    "\n",
    "We also need to test membership of an assemblage in the quantum set of assemblages. Since this set has a complicated structure, we will use an outer approximation to it, such that membership can be tested via semidefinite programming. \n",
    "\n",
    "Given an assemblage $\\sigma_{AB|XY} = \\{\\sigma_{ab|xy}\\}_{a,b,x,y} \\equiv \\{\\sigma_R, \\sigma_x^A, \\sigma_y^B, \\sigma_{xy}\\}_{x,y}$ in the case of dichotomic measurements, we solve the following optimisation problem, which is the robustness-based version of the membership problem:\n",
    "\n",
    "\\begin{align}\n",
    "\\min_{p,\\pi_{AB|XY}} &\\quad p \\\\\n",
    "\\text{s.t.}&\\quad \\frac{\\sigma_{AB|XY} + p \\pi_{AB|XY}}{1+p} \\in \\tilde{\\mathcal{Q}} \\\\\n",
    "&\\quad p \\geq 0\n",
    "\\end{align}\n",
    "where $\\tilde{\\mathcal{Q}}$ is an approximation to the quantum set of assemblages. If the solution to this problem is $p = 0$, then $\\sigma_{AB|XY}$ belongs to the quantum set of assemblages. If $p > 0$, then $\\sigma_{AB|XY} \\notin \\tilde{\\mathcal{Q}}$, as it is necessary to add a non-zero amount of noise $\\pi_{AB|XY}$ in order to bring the assemblage inside the quantum set. \n",
    "\n",
    "In this work we use the [Almost-Quantum](https://doi.org/10.1103/PhysRevLett.115.190403) (AQ) SDP relaxation of the quantum set. This test asks that there exists a positive-semidefinite moment matrix $\\Gamma \\geq 0$, which satisfies constraints which arise from the algebra of projectors, and which is consistent with the observed assemblage. The explicit details of these constraints can be found [here](https://doi.org/10.1103/PhysRevLett.115.190403). \n",
    "\n",
    "Because of the duality theory of semidefinite programs, if the assemblage is outside the AQ set of assemblages, there exists a linear functional that certies this fact, i.e. a set of operators $\\{F_R, F_x^A, F_y^B, F_{xy}\\}_{x,y}$, such that  \n",
    "\n",
    "$$ \\beta = \\mathrm{tr}\\left[\\sigma_R F_R + \\sum_x \\sigma_x^A F_x^A + \\sum_y \\sigma_y^B F_y^B + \\sum_{xy} \\sigma_{xy}F_{xy} \\right] > 0$$\n",
    "while for all quantum assemblages $\\beta \\leq 0$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file IsAQAssemblage.m\n",
    "\n",
    "function [output,Fr,Fx,Fy,F,beta,Gamma] = IsAQAssemblage(Sr,Sx,Sy,S,ma,mb)\n",
    "\n",
    "% given an assemblage in CG notation, this function determines whether it belongs to the \n",
    "% Almost-Quantum outer approximation to the set of quantum assemblages. \n",
    "% This function returns out=0 if the assemblage is outside and out=1 if inside.\n",
    "%\n",
    "% Steering scenario with two uncharacterised parties (Alice and Bob), and\n",
    "% one characterised one (Charlie).\n",
    "%\n",
    "% mb = number of measurements for Alice\n",
    "% mc = number of measurements for Bob\n",
    "%\n",
    "% this code assumes that all measurements are dichotomic\n",
    "\n",
    "\n",
    "d=size(Sr,1); \n",
    "dimG=(ma+1)*(mb+1)*d; \n",
    "\n",
    "cvx_begin sdp quiet\n",
    "\n",
    "    variable Gamma(dimG,dimG) hermitian % moment matrix\n",
    "    \n",
    "    variable pi_r(d,d) hermitian \n",
    "    variable pix(d,d,ma) hermitian \n",
    "    variable piy(d,d,mb) hermitian \n",
    "    variable pixy(d,d,ma*mb) hermitian semidefinite\n",
    "\n",
    "    dual variable Fr\n",
    "    dual variables Fx{ma}\n",
    "    dual variables Fy{mb}\n",
    "    dual variables F{ma*mb}\n",
    "            \n",
    "    minimise trace(pi_r)\n",
    "            \n",
    "    Gamma == hermitian_semidefinite(dimG);\n",
    "                \n",
    "    for x = 1:ma\n",
    "        for y = 1:mb\n",
    "            pix(:,:,x)-pixy(:,:,x+ma*(y-1)) == hermitian_semidefinite(d);\n",
    "            piy(:,:,y)-pixy(:,:,x+ma*(y-1)) == hermitian_semidefinite(d);\n",
    "            pi_r-pix(:,:,x)-piy(:,:,y)+pixy(:,:,x+ma*(y-1)) == hermitian_semidefinite(d);\n",
    "        end\n",
    "    end\n",
    "            \n",
    "    % First row\n",
    "    Fr : Gamma(1:d,1:d)==Sr+pi_r;\n",
    "                \n",
    "    % Alice's marginal assemblage\n",
    "    for k=1:ma\n",
    "        Fx{k} : Gamma(1:d,k*d+1:(k+1)*d)==Sx(:,:,k)+pix(:,:,k);\n",
    "    end\n",
    "                \n",
    "    % Bob's marginal assemblage\n",
    "    for k=1:mb\n",
    "        Fy{k} : Gamma(1:d,k*d*(ma+1)+1:k*d*(ma+1)+d)==Sy(:,:,k) + piy(:,:,k);\n",
    "    end\n",
    "\n",
    "    % the assemblage for all-but-one outcome\n",
    "    for k=1:ma\n",
    "        for j=1:mb\n",
    "            F{ma*(j-1)+k} : Gamma(1:d,j*d*(ma+1)+k*d+1:j*d*(ma+1)+k*d+d)...\n",
    "                == S(:,:,ma*(j-1)+k) + pixy(:,:,ma*(j-1)+k);\n",
    "        end\n",
    "    end\n",
    "            \n",
    "    % Conditions on Gamma to be AQ                \n",
    "    for y=0:ma\n",
    "        for z=0:mb\n",
    "            for yp=0:ma\n",
    "                for zp=0:mb \n",
    "                    if y==0 && z==0 % reductions of type AB, where it can be A=1 and/or B=1\n",
    "                        r1=1;\n",
    "                        c1=zp*d*(ma+1)+yp*d+1;\n",
    "                        r2=yp*d+1;\n",
    "                        c2=zp*d*(ma+1)+1;\n",
    "                        r3=yp*d+1;\n",
    "                        c3=zp*d*(ma+1)+yp*d+1;\n",
    "                        r4=zp*d*(ma+1)+1;\n",
    "                        c4=zp*d*(ma+1)+yp*d+1;\n",
    "                        r5=zp*d*(ma+1)+yp*d+1;\n",
    "                        c5=zp*d*(ma+1)+1;\n",
    "                        r6=zp*d*(ma+1)+yp*d+1;\n",
    "                        c6=zp*d*(ma+1)+yp*d+1;\n",
    "                        r7=zp*d*(ma+1)+1;\n",
    "                        c7=yp*d+1;\n",
    "                        r8=zp*d*(ma+1)+yp*d+1;\n",
    "                        c8=1;\n",
    "                        r9=zp*d*(ma+1)+yp*d+1;\n",
    "                        c9=yp*d+1;\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r3:r3+d-1,c3:c3+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r4:r4+d-1,c4:c4+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r5:r5+d-1,c5:c5+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r6:r6+d-1,c6:c6+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r7:r7+d-1,c7:c7+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r8:r8+d-1,c8:c8+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r9:r9+d-1,c9:c9+d-1);\n",
    "                    end\n",
    "                    \n",
    "                    if y==0 && z~=0 && yp~=0 && zp~=0 % Reduction of type ABB', none = 1. \n",
    "                        r1=z*d*(ma+1)+1;\n",
    "                        c1=zp*d*(ma+1)+yp*d+1;\n",
    "                        r2=z*d*(ma+1)+yp*d+1;\n",
    "                        c2=zp*d*(ma+1)+1;\n",
    "                        r3=z*d*(ma+1)+yp*d+1;\n",
    "                        c3=zp*d*(ma+1)+yp*d+1;\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r3:r3+d-1,c3:c3+d-1);\n",
    "                    end\n",
    "                    \n",
    "                    if z~=0 && yp==0 && zp~=0 % (AB,A')=(A'B,A)', B can be =1.\n",
    "                        if z~=zp\n",
    "                            r1=z*d*(ma+1)+y*d+1;\n",
    "                            c1=zp*d*(ma+1)+1;\n",
    "                            r2=zp*d*(ma+1)+y*d+1;\n",
    "                            c2=z*d*(ma+1)+1;\n",
    "                            Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1)';\n",
    "                        end\n",
    "                    end\n",
    "                    \n",
    "                    if z==0 && y~=0 && yp~=0 && zp~=0 % Reduction of type AA'B, none = 1.\n",
    "                        r1=y*d+1;\n",
    "                        c1=zp*d*(ma+1)+yp*d+1;\n",
    "                        r2=zp*d*(ma+1)+y*d+1;\n",
    "                        c2=yp*d+1;\n",
    "                        r3=zp*d*(ma+1)+y*d+1;\n",
    "                        c3=zp*d*(ma+1)+yp*d+1;\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1);\n",
    "                        Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r3:r3+d-1,c3:c3+d-1);\n",
    "                    end\n",
    "                    \n",
    "                    if y~=0 && yp~=0 && zp==0 % (AB,B')=(AB',B)'\n",
    "                        if y~=yp\n",
    "                            r1=z*d*(ma+1)+y*d+1;\n",
    "                            c1=yp*d+1;\n",
    "                            r2=z*d*(ma+1)+yp*d+1;\n",
    "                            c2=y*d+1;\n",
    "                            Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1)';\n",
    "                        end                        \n",
    "                    end\n",
    "                    \n",
    "                    if y~=0 && z~=0 && yp~=0 && zp==0 % (AB, A'B') = (A'B',AB)'\n",
    "                        if y~=yp && z~=zp\n",
    "                            r1=z*d*(ma+1)+y*d+1;\n",
    "                            c1=zp*d*(ma+1)+yp*d+1;\n",
    "                            r2=zp*d*(ma+1)+yp*d+1;\n",
    "                            c2=z*d*(ma+1)+y*d+1;\n",
    "                            Gamma(r1:r1+d-1,c1:c1+d-1)==Gamma(r2:r2+d-1,c2:c2+d-1)';\n",
    "                        end                                            \n",
    "                    end\n",
    "                end\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    cvx_end\n",
    "    \n",
    "    threshold = 1e-8; % threshold for being 'inside' AQ (i.e. anything smaller will be considered inside, anything larger outside)\n",
    "    \n",
    "    output=cvx_optval <= threshold;\n",
    "    beta = cvx_optval;\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Breuer Map\n",
    "\n",
    "The first example will be to use the state in $\\mathbb{C}^2 \\otimes \\mathbb{C}^2 \\otimes \\mathbb{C}^4$ given in (38). For measurements we will use the CHSH measurements, and for the positive map we will use the Breuer map. We will see that this leads to post-quantum steering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output =\n",
      "  logical\n",
      "   1\n",
      "output =\n",
      "  logical\n",
      "   0\n",
      "beta =\n",
      "    0.0210\n",
      "Fr =\n",
      "  -0.3684 + 0.0000i  -0.0631 + 0.2282i   0.0753 + 0.3295i   0.0000 - 0.0000i\n",
      "  -0.0631 - 0.2282i  -0.5822 + 0.0000i   0.0000 + 0.0000i   0.0753 + 0.3295i\n",
      "   0.0753 - 0.3295i   0.0000 - 0.0000i  -0.5822 + 0.0000i   0.0631 - 0.2282i\n",
      "   0.0000 + 0.0000i   0.0753 - 0.3295i   0.0631 + 0.2282i  -0.3684 + 0.0000i\n",
      "Fx{1} =\n",
      "  -0.0000 + 0.0056i  -0.0571 + 0.0336i   0.0179 + 0.2146i   0.0000 + 0.1057i\n",
      "   0.3096 + 0.0336i   0.0000 - 0.0168i   0.0000 - 0.1195i  -0.1686 + 0.2146i\n",
      "  -0.3193 + 0.2146i  -0.0000 - 0.1195i   0.0000 + 0.0168i  -0.1834 - 0.0336i\n",
      "  -0.0000 + 0.1057i  -0.1328 + 0.2146i  -0.0691 - 0.0336i  -0.0000 - 0.0056i\n",
      "Fx{2} =\n",
      "  -0.0508 - 0.0000i  -0.0001 + 0.0223i  -0.0002 + 0.1814i   0.0210 - 0.0001i\n",
      "   0.0001 + 0.3979i   0.0270 + 0.0000i   0.0318 - 0.0001i   0.0001 + 0.2114i\n",
      "   0.0002 - 0.0590i  -0.0318 - 0.0001i   0.0270 - 0.0000i   0.0001 + 0.0343i\n",
      "  -0.0210 - 0.0001i  -0.0001 - 0.0290i  -0.0001 - 0.3413i  -0.0508 + 0.0000i\n",
      "Fy{1} =\n",
      "   0.0602 + 0.0012i   0.0638 + 0.0160i  -0.0312 + 0.1574i   0.0596 - 0.0280i\n",
      "   0.1857 + 0.2845i  -0.0959 + 0.0008i   0.0617 + 0.0125i  -0.0536 + 0.1742i\n",
      "  -0.1790 + 0.0200i  -0.0617 + 0.0125i  -0.0959 - 0.0008i  -0.0317 + 0.0985i\n",
      "  -0.0596 - 0.0280i  -0.1566 + 0.0368i  -0.2177 - 0.1701i   0.0602 - 0.0012i\n",
      "Fy{2} =\n",
      "  -0.1110 + 0.0022i   0.0411 + 0.0513i   0.0882 + 0.2195i   0.0484 - 0.0247i\n",
      "  -0.0380 + 0.3199i   0.1230 - 0.0020i   0.0799 + 0.0254i   0.0694 + 0.2658i\n",
      "   0.1219 + 0.1165i  -0.0799 + 0.0254i   0.1230 + 0.0020i   0.0134 + 0.0660i\n",
      "  -0.0484 - 0.0247i   0.1408 + 0.1627i  -0.0165 - 0.2026i  -0.1110 - 0.0022i\n",
      "F{1} =\n",
      "   (1,1)     -0.1712 + 0.0000i\n",
      "   (2,1)     -0.2525 + 0.0000i\n",
      "   (3,1)      0.0000 + 0.0343i\n",
      "   (4,1)     -0.0000 + 0.0000i\n",
      "   (2,2)      0.2189 + 0.0000i\n",
      "   (3,2)     -0.0000 - 0.0000i\n",
      "   (4,2)      0.0000 + 0.0343i\n",
      "   (3,3)      0.2189 + 0.0000i\n",
      "   (4,3)      0.2525 - 0.0000i\n",
      "   (4,4)     -0.1712 + 0.0000i\n",
      "F{2} =\n",
      "   (1,1)      0.0508 + 0.0000i\n",
      "   (2,1)     -0.2463 - 0.0000i\n",
      "   (3,1)      0.0000 + 0.2404i\n",
      "   (4,1)      0.0000 - 0.0000i\n",
      "   (2,2)     -0.0270 + 0.0000i\n",
      "   (3,2)     -0.0000 + 0.0000i\n",
      "   (4,2)      0.0000 + 0.2404i\n",
      "   (3,3)     -0.0270 + 0.0000i\n",
      "   (4,3)      0.2463 + 0.0000i\n",
      "   (4,4)      0.0508 + 0.0000i\n",
      "F{3} =\n",
      "   (1,1)      0.1712 + 0.0000i\n",
      "   (2,1)     -0.2525 - 0.0000i\n",
      "   (3,1)     -0.0000 - 0.0343i\n",
      "   (4,1)     -0.0000 + 0.0000i\n",
      "   (2,2)     -0.2189 + 0.0000i\n",
      "   (3,2)     -0.0000 - 0.0000i\n",
      "   (4,2)     -0.0000 - 0.0343i\n",
      "   (3,3)     -0.2189 + 0.0000i\n",
      "   (4,3)      0.2525 + 0.0000i\n",
      "   (4,4)      0.1712 + 0.0000i\n",
      "F{4} =\n",
      "   (1,1)      0.0508 + 0.0000i\n",
      "   (2,1)      0.2463 + 0.0000i\n",
      "   (3,1)      0.0000 + 0.2404i\n",
      "   (4,1)     -0.0000 + 0.0000i\n",
      "   (2,2)     -0.0270 + 0.0000i\n",
      "   (3,2)     -0.0000 + 0.0000i\n",
      "   (4,2)      0.0000 + 0.2404i\n",
      "   (3,3)     -0.0270 + 0.0000i\n",
      "   (4,3)     -0.2463 - 0.0000i\n",
      "   (4,4)      0.0508 + 0.0000i\n"
     ]
    }
   ],
   "source": [
    "% Initialise state: \n",
    "\n",
    "Id16 = eye(16);\n",
    "\n",
    "psi=Id16(:,2)+Id16(:,3)+Id16(:,5)+Id16(:,9);\n",
    "psi=psi+1i*(Id16(:,4)+Id16(:,6)+Id16(:,7)+Id16(:,10)+Id16(:,11)+Id16(:,13));\n",
    "psi=psi-(Id16(:,8)+Id16(:,12)+Id16(:,14)+Id16(:,15));\n",
    "psi=psi/norm(psi);\n",
    "rho=psi*psi';\n",
    "\n",
    "% measurements\n",
    "\n",
    "ma = 2;\n",
    "mb = 2;\n",
    "\n",
    "Ma = zeros(2,2,ma);\n",
    "Mb = zeros(2,2,mb);\n",
    "\n",
    "Ma(:,:,1) = (Pauli(4)+Pauli(1))/2;\n",
    "Ma(:,:,2) = (Pauli(4)+Pauli(3))/2;\n",
    "\n",
    "Mb(:,:,1) = (Pauli(4)+(Pauli(1)+Pauli(3))/sqrt(2))/2;\n",
    "Mb(:,:,2) = (Pauli(4)+(-Pauli(1)+Pauli(3))/sqrt(2))/2;\n",
    "\n",
    "% generate assemblage\n",
    "\n",
    "[Sr,Sx,Sy,S] = GenerateAssem(rho, Ma, Mb);\n",
    "\n",
    "% check for membership in AQ before applying map\n",
    "\n",
    "output = IsAQAssemblage(Sr,Sx,Sy,S,ma,mb)\n",
    "\n",
    "% check for membership in AQ after applying Breuer map\n",
    "\n",
    "U = Tensor(Pauli(1),Pauli(2));\n",
    "[Rr, Rx, Ry, R] = BreuerMapOnAssem(U, Sr, Sx, Sy,S,ma,mb);\n",
    "\n",
    "[output,Fr,Fx,Fy,F,beta] = IsAQAssemblage(Rr,Rx,Ry,R,ma,mb);\n",
    "output\n",
    "beta\n",
    "\n",
    "Fr\n",
    "celldisp(Fx)\n",
    "celldisp(Fy)\n",
    "celldisp(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: Choi map\n",
    "\n",
    "Our second example will be to use as choice of positive map the [Choi map][1] on $\\mathbb{C}^3$. \n",
    "\n",
    "As a state, we will consider a pure state in $\\mathbb{C}^2 \\otimes \\mathbb{C}^2 \\otimes \\mathbb{C}^3$ which is the Dicke state with 2 excitations\n",
    "\n",
    "$$ \\left|\\psi\\right\\rangle = \\frac{1}{2}\\left(\\left|011\\right\\rangle + \\left|002\\right\\rangle + \\left|101\\right\\rangle + \\left|110\\right\\rangle\\right)$$\n",
    "\n",
    "We will use the same (CHSH) measurements as in the previous example. \n",
    "\n",
    "[1]: https://doi.org/10.1016/0024-3795(75)90075-0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output =\n",
      "  logical\n",
      "   1\n",
      "output =\n",
      "  logical\n",
      "   0\n",
      "beta =\n",
      "    0.0110\n",
      "Fr =\n",
      "   -0.0762    0.1437    0.0126\n",
      "    0.1437   -0.2713   -0.0240\n",
      "    0.0126   -0.0240   -0.0121\n",
      "Fx{1} =\n",
      "   -0.0000   -0.0255    0.0232\n",
      "   -0.5495   -0.0000    0.0438\n",
      "   -0.0232    0.0523    0.0000\n",
      "Fx{2} =\n",
      "   -0.0007   -0.0000    0.0243\n",
      "    0.0000    0.0000    0.0000\n",
      "    0.0281    0.0000   -0.9850\n",
      "Fy{1} =\n",
      "   -0.1152   -0.1026    0.2165\n",
      "   -0.0362    0.1280    0.0019\n",
      "    0.2089   -0.0276   -0.2757\n",
      "Fy{2} =\n",
      "    0.0329   -0.0206   -0.0476\n",
      "   -0.1314    0.1433   -0.0021\n",
      "   -0.0775    0.0757   -0.2397\n",
      "F{1} =\n",
      "    0.1481         0         0\n",
      "    0.2907    0.0152         0\n",
      "   -0.5505   -0.0479    0.0360\n",
      "F{2} =\n",
      "    0.0051         0         0\n",
      "    0.0142   -0.0000         0\n",
      "   -0.1918   -0.4704    0.7562\n",
      "F{3} =\n",
      "   -0.1481         0         0\n",
      "    0.2907   -0.0152         0\n",
      "    0.5505   -0.0479   -0.0360\n",
      "F{4} =\n",
      "    0.0051         0         0\n",
      "   -0.0142   -0.0000         0\n",
      "   -0.1918    0.4704    0.7562\n"
     ]
    }
   ],
   "source": [
    "clear\n",
    "\n",
    "% initialise a random state\n",
    "\n",
    "% we assume the state is 2 x 2 x 3 with Charlie the trusted party\n",
    "\n",
    "psi = zeros(12,1); % |psi> = (|002> + |011> + |101> + |110>)/2\n",
    "psi(3) = 1;        % (2 excitation Dicke state)\n",
    "psi(5) = 1;\n",
    "psi(8) = 1;\n",
    "psi(10) = 1;\n",
    "rho = psi*psi';\n",
    "rho = rho/trace(rho);\n",
    "\n",
    "% we can prepare the opeator O by applying the Choi map to C\n",
    "\n",
    "rhoC = PartialMap(rho,ChoiMap,2,[4,3]);\n",
    "\n",
    "% initialise randomly chosen projective measurements\n",
    "\n",
    "ma = 2;\n",
    "mb = 2;\n",
    "\n",
    "Ma = zeros(2,2,ma);\n",
    "Mb = zeros(2,2,mb);\n",
    "\n",
    "Ma(:,:,1) = (Pauli(4)+Pauli(1))/2;\n",
    "Ma(:,:,2) = (Pauli(4)+Pauli(3))/2;\n",
    "\n",
    "Mb(:,:,1) = (Pauli(4)+(Pauli(1)+Pauli(3))/sqrt(2))/2;\n",
    "Mb(:,:,2) = (Pauli(4)+(-Pauli(1)+Pauli(3))/sqrt(2))/2;\n",
    "\n",
    "% generate assemblages\n",
    "\n",
    "[Sr,Sx,Sy,S] = GenerateAssem(rho,Ma,Mb);\n",
    "[Rr,Rx,Ry,R] = GenerateAssem(rhoC,Ma,Mb);\n",
    "\n",
    "% check for membership in AQ before applying map\n",
    "\n",
    "output = IsAQAssemblage(Sr,Sx,Sy,S,ma,mb)\n",
    "\n",
    "% check for membership in AQ after applying Breuer map\n",
    "\n",
    "[output, Fr, Fx, Fy, F, beta,Gam] = IsAQAssemblage(Rr,Rx,Ry,R,ma,mb);\n",
    "output\n",
    "beta\n",
    "\n",
    "Fr\n",
    "celldisp(Fx)\n",
    "celldisp(Fy)\n",
    "celldisp(F)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Matlab",
   "language": "matlab",
   "name": "matlab"
  },
  "language_info": {
   "codemirror_mode": "octave",
   "file_extension": ".m",
   "help_links": [
    {
     "text": "MetaKernel Magics",
     "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
    }
   ],
   "mimetype": "text/x-octave",
   "name": "matlab",
   "version": "0.15.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}