new port quantum information

Author: GiggleLiu

examples/PortQuantumInfromation/yao_port_qi.ipynb

@@ -0,0 +1,374 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Porting Yao.jl with QuantumInformation.jl\n",
+    "### GiggleLiu"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# overview\n",
+    "\n",
+    " [`Yao`](https://github.com/QuantumBFS/Yao.jl) is a powerful tool for quantum circuit based simulation, but it does not support many density matrix related operations. This is why we need to port `Yao.jl` with [`QuantumInformation (QI)`](https://github.com/QuantumBFS/QuantumInformation.jl) sometimes (e.g. for computing entanglement entropy).\n",
+    " \n",
+    "* `Yao.jl` Documentation: https://quantumbfs.github.io/Yao.jl/latest/ (paper is comming out)\n",
+    "* `QuantumInformation.jl` paper: https://arxiv.org/abs/1806.11464\n",
+    "     \n",
+    "### `Yao` provides\n",
+    "* high performance quantum circuit based simulation\n",
+    "    * parameter management\n",
+    "    * gradients\n",
+    "    * batched regiser\n",
+    "* operator matrix representation and arithmatics\n",
+    "* [quantum algorithms](https://github.com/QuantumBFS/QuAlgorithmZoo.jl)\n",
+    "* [GPU support](https://github.com/QuantumBFS/CuYao.jl)\n",
+    "\n",
+    "### `QI` provides\n",
+    "\n",
+    "* Compute entropy from density matrices\n",
+    "* Quantum channels, four types of channel representations\n",
+    "    * Kraus Operator\n",
+    "    * Super operator\n",
+    "    * Dynamic matrices\n",
+    "    * Stinespring representation\n",
+    "* Compute norm, distance and distingushability between \"states\" (density matrices)\n",
+    "    * Hilbert–Schmidt norm and distance\n",
+    "    * trace norm and *distance*\n",
+    "    * diamond norm\n",
+    "    * Bures distane and Bures angles\n",
+    "    * *fidelity* and superfidelity\n",
+    "    * KL-divergence\n",
+    "    * JS-distance\n",
+    "* Compute the amount of entanglement\n",
+    "     * negativity\n",
+    "     * positive partial trace\n",
+    "     * concurrence\n",
+    "* POVM measurements"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import Yao\n",
+    "using Yao: ArrayReg, ρ, mat, ConstGate, purify, exchange_sysenv, @bit_str, statevec\n",
+    "import QuantumInformation; const QI = QuantumInformation\n",
+    "using QuantumInformation: ket\n",
+    "using LinearAlgebra\n",
+    "using Test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Obtain reduced density matrices in Yao\n",
+    "-------------------------\n",
+    "The memory layout of `Yao` register and `QI` ket are similar, their basis are both [little endian](https://en.wikipedia.org/wiki/Endianness), despite they have different representation powers\n",
+    "\n",
+    "* `Yao` support batch,\n",
+    "* `QI` is not limited to qubits.\n",
+    "\n",
+    "\n",
+    "`Yao` does not have much operations defined on density matrices, but purified states with environment,\n",
+    "On the other side, most operations in `QI` are defined on **(density) matrices**, they can be easily obtained in `Yao`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# construct a product state, notice the indexing in `QI` starts from `1`\n",
+    "@test QI.ket(3, 1<<4) ≈ statevec(ArrayReg(bit\"0010\"))\n",
+    "\n",
+    "# join two registers, notice little endian convension is used here.\n",
+    "reg = join(ArrayReg(bit\"10\"), ArrayReg(bit\"11\"))\n",
+    "v = QI.:⊗(QI.ket(0b10+1,1<<2), QI.ket(0b11+1,1<<2))\n",
+    "@test statevec(reg) ≈ v"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "16×16 Array{Complex{Float64},2}:\n",
+       "   0.0668399+0.0im         …    0.0048149+0.00800254im \n",
+       " -0.00683079+0.00430075im      0.00271044+0.013467im   \n",
+       " -0.00405524-0.00233655im      0.00489161-0.00506099im \n",
+       "   0.0041184-0.00690317im     -0.00724508+0.00433365im \n",
+       " 0.000248112-0.00614303im     -0.00169715-0.0060107im  \n",
+       " -0.00638715+0.00343611im  …  -0.00346919+0.0104737im  \n",
+       "  -0.0032589-0.00594789im     -0.00502371+0.00889227im \n",
+       "   0.0053714-0.00448422im     0.000149836+0.00490488im \n",
+       " -0.00485418+0.00190183im     -0.00707738-0.0117206im  \n",
+       " -0.00185245-0.0113168im      -0.00100021+0.00456715im \n",
+       " 0.000202351+0.00648573im  …   9.29962e-5-0.00362312im \n",
+       "   0.0038004-0.00408768im      0.00290617+0.0109155im  \n",
+       " -0.00488166-0.00699333im     -0.00471523+0.000137239im\n",
+       "  0.00485705+0.00532262im      0.00956895-0.00457732im \n",
+       "  0.00756613-0.00569826im       0.0032851+0.0014402im  \n",
+       "   0.0048149-0.00800254im  …    0.0786938+0.0im        "
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# convert a Yao register to density matrix in QI\n",
+    "reg2dm(reg::ArrayReg{1}) = reg |> ρ |> Matrix\n",
+    "\n",
+    "# e.g. obtain a reduced denstiy matrix for subsystem 1,2,3,4\n",
+    "reg = Yao.rand_state(10)\n",
+    "freg = Yao.focus!(reg, 1:4) # make qubits 1-4 active\n",
+    "reg2dm(freg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One can also convert a density matrix to a a quantum state through **purification**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# e.g. purify a state and recover it\n",
+    "reg = Yao.rand_state(6) |> Yao.focus!(1:4)\n",
+    "reg_p = purify(reg |> ρ; nbit_env=2)\n",
+    "@test Yao.fidelity(reg, reg_p)[] ≈ 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "entanglement & state distance\n",
+    "----------------\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reg1 = Yao.rand_state(10)\n",
+    "freg1 = Yao.focus!(reg1, 1:4)\n",
+    "reg2 = Yao.rand_state(6)\n",
+    "freg2 = Yao.focus!(reg2, 1:4)\n",
+    "dm1, dm2 = freg1 |> reg2dm, freg2 |> reg2dm\n",
+    "\n",
+    "# trace distance between two registers (different by a factor 2)\n",
+    "@test Yao.tracedist(freg1, freg2)[]/2 ≈ QI.trace_distance(dm1, dm2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "QI.vonneumann_entropy(dm1) = 2.6568839293081608\n",
+      "QI.vonneumann_entropy(dm2) = 1.3245543916726097\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1.3245543916726097"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# get the entanglement entropy between system and env\n",
+    "@show QI.vonneumann_entropy(dm1)\n",
+    "@show QI.vonneumann_entropy(dm2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.5694621854109723"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# KL-divergence (or relative entropy)\n",
+    "QI.kl_divergence(dm2, dm1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note: you can defined many distances and entropies in a similar way, we don't enumerate it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quantum Operations/Quantum Gates\n",
+    "------------------------\n",
+    "\n",
+    "A quantum gate in `Yao` is equivalent to a unitary channel in `QI`, matrix representations of blocks in `Yao` can be used to construct channels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "QuantumInformation.KrausOperators{Array{Complex{Float64},2}}\n",
+       "    dimensions: (2, 2)\n",
+       "    Complex{Float64}[1.0 + 0.0im 0.0 + 0.0im; 0.0 + 0.0im 0.0 + 0.0im]\n",
+       "    Complex{Float64}[0.0 + 0.0im 0.0 + 0.0im; 0.0 + 0.0im 1.0 + 0.0im]\n",
+       "    Complex{Float64}[0.0 + 0.0im 1.0 + 0.0im; 0.0 + 0.0im 0.0 + 0.0im]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# construct a Kraus Operator\n",
+    "QI.KrausOperators([Matrix(ConstGate.P0), Matrix(ConstGate.P1), Matrix(ConstGate.Pu)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":(#= In[24]:9 =# @test (copy(reg) |> Yao.chain(b1, b2)) |> reg2dm ≈ (c2 ∘ c1)(reg |> reg2dm))"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# applying a rotation gate\n",
+    "b1 = Yao.put(2,2=>Yao.Rx(0.3π))\n",
+    "c1 = QI.UnitaryChannel(mat(b1))\n",
+    "b2 = Yao.put(2,2=>Yao.Ry(0.3π))\n",
+    "c2 = QI.UnitaryChannel(mat(b2))\n",
+    "\n",
+    "reg = Yao.rand_state(2)\n",
+    "@test copy(reg) |> b1 |> reg2dm ≈ c1(reg |> reg2dm)\n",
+    ":@test copy(reg) |> Yao.chain(b1,b2) |> reg2dm ≈ (c2∘c1)(reg |> reg2dm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "@webio": {
+   "lastCommId": null,
+   "lastKernelId": null
+  },
+  "kernelspec": {
+   "display_name": "Julia 1.3.0",
+   "language": "julia",
+   "name": "julia-1.3"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.3.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}