problems/week2/week2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week2: Groverのアルゴリズム\n",
    "\n",
    "*下記の文章の解説部分はIBM Q ExprienceのQuantum Algorithms with Qiskit内の [Grover's algorithm and its Qiskit implementation](https://quantum-computing.ibm.com/support/guides/quantum-algorithms-with-qiskit?page=5cc0d9fd86b50d00642353ca#) の抄訳ですが、\"Qiskitでの実装\"以降の部分は本チャレンジ用に新規作成しています。*\n",
    "\n",
    "ウィーク２へようこそ！今週は、量子アルゴリズムの一つであるGrover (グローバー) のアルゴリズムについて学びます。 そして、**当チュートリアルの最後には今週の問題（ラーニングチャレンジ演習Ⅱ）がありますので、ぜひチャレンジしてみてください。** \n",
    "\n",
    "古典コンピューターを凌駕する量子コンピューターの数あるアドバンテージの１つに、データベース検索を高速に行えるというのを聞いたことがあるかも知れません。Groverのアルゴリズムはこの能力を実証します。Groverのアルゴリズムは、非構造化データの検索問題に対して二次のオーダーの高速化ができるだけではなく、検索を超えて利用することができます。つまり、その他様々のアルゴリズムの実行時間を二次のオーダーで改善する一般的なテクニック、もしくはサブルーチンとして利用することができます。これは振幅増幅テクニックと呼ばれています。\n",
    "\n",
    "このページでは、検索問題の詳細を説明し、検索問題用のオラクル(Oracle)を回路で作成した後にGroverのアルゴリズムをQisKitを利用して実装します。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 非構造化データの検索\n",
    "$N$個の大きなアイテムリストがあるとします。その中で、一つだけアタリ$w$があるとします。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./fig/unstructured_search.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "アタリの箱（マークのついたアイテム）を見つけるためには、古典計算では平均で $N/2$ 個の箱を探す必要があります。\n",
    "最悪の場合は、$N$ 個探す必要があります。ところが、量子コンピューターでは Groverの振幅増幅のテクニックを使って、\n",
    "おおよそ $\\sqrt N$ ステップでマークされたアイテムを探し出すことができます。\n",
    "二次の高速化は、大きなリスト内のマークされたアイテムを探すためには実際の所、大きな時間の節約になります。\n",
    "さらに、このアルゴリズムはリスト自体の内部構造を利用しないので、一般化することができ、多くの古典の問題でも二次の速度向上をもたらしてくれます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# オラクル\n",
    "量子コンピューターにこのようなリストをどのように提供すればいいでしょうか？このようなリストをエンコードするためによく用いられる手法としては、マークのついていない$x$には$f(x)=0$を返し、アタリ$w$に対しては$f(w)=1$を返すような関数$f$を定義する手法が挙げられます。この問題に対して量子コンピューターを使用するには、この関数に対して、重ね合わせ状態にあるアイテムを提供する必要があります。つまり、この関数をオラクルと呼ばれるユニタリー行列としてエンコードする必要があります。そのために、まず初めにアイテムをバイナリ表現にします。すなわち、$x,w \\in \\{0,1\\}^n$で$N=2^n$です。このようにすると量子コンピューター上の量子ビットとして表現することができます。その後、オラクル行列$U_w$を任意の標準基底$|x>$に対して$U_w |x> =(-1)^{f(x)}|x>$となるように定義します。\n",
    "\n",
    "$x$がマークされていないアイテムの場合、オラクルは状態に対して何もしません。ところが、状態$|w>$に対してオラクルを適用すると、$U_w |w> = -|w>$にマッピングします。幾何学的には、このユニタリー行列は$N=2^n$次元のベクトル空間において、マークされたアイテムを原点に対して反転する操作に対応しています。\n",
    "\n",
    "<img src=\"./fig/oracle.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 振幅増幅（Amplitude amplification）\n",
    "では、アルゴリズムはどのように動作するのでしょう？リストを調べる前は、私たちはマークされたアイテムがどこにあるのか知りません。従って、私たちの推測は、下記の式で表される均一な重ね合わせ状態での位置特定と大差ありません。\n",
    "$$ |s> = \\frac{1}{\\sqrt N}\\sum_{x=0}^{N-1} |x> $$\n",
    "\n",
    "もしこの時点で標準基底 $|x> $でこの重ね合わせ状態を測定した場合、$\\frac{1}{N} = \\frac{1}{2^{n}} $ の確率で、標準基底のうちの一つに収束します。予想通り、正しい$|w>$を当てる確率は$\\frac{1}{2^{n}}$ です。従って、正しいアイテムを推測するには、平均$N=2^{n}$回トライする必要があります。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "そこで振幅増幅と呼ばれる処理を加えましょう。この処理により、量子コンピューターが正しいアイテムを見つける確率を大幅に高めることが出来ます。この処理では、マークされたアイテムの振幅を増幅し、その他のアイテムの振幅を小さくします。この結果、最終状態を測定すると、正しいアイテムをほぼ確実に取り出すことができるようになります。\n",
    "\n",
    "このアルゴリズムには２つの反転という面白い幾何学的解釈があり、２次元平面での回転として表せます。私たちが考慮すべきは、アタリ$|w>$ と均一な重ね合わせ状態$|s>$ の２つの特別な状態のみです。この２つのベクトルは、ベクトル空間 $\\mathbb C^{N}$ において、２次元の平面を張ります。$|w>$ 状態は、$N^{-1/2}$ の振幅で重ね合わせ状態に入っているため、これら２つのベクトルは完全に直交しているわけではありません。\n",
    "\n",
    "しかし、$|s>$ から $|w>$ を削除し、正規化し直す事で$|w>$ に直交する追加の状態 $|s'>$ を導入することができます\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 0:\n",
    "振幅増幅は均一な重ね合わせ状態 $|s>$ から開始します。均一な重ね合わせ状態は、$|s> = H^{\\otimes n}|0>^{n}$ により簡単に作成できます。$t=0$ の時、初期状態は $|\\psi_{0}> = |s>$ です。\n",
    "<img src=\"./fig/step0.png\" width=\"700\">\n",
    "左の図は、$|w>, |s'>$ によって張られる、２次元平面に対応しています。右の図は、$N=2^n$ の場合の、状態 $|\\psi_{t}>$ の振幅を表す棒グラフです。振幅の平均値は破線で示されています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1:\n",
    "反転のオラクル $U_{w}$ を状態に適用します $U_{w}|\\psi_{t}> = |\\psi_{t'}>$\n",
    "<img src=\"./fig/step1.png\" width=\"700\">\n",
    "幾何学的には、状態 $|\\psi_{t}>$ を $|s'>$ に対して反転させることに対応しています。この変換が意味することは、$|w>$ 状態の振幅が負の値になるということで、結果として平均振幅が低くなることを意味しています。(訳注：右側のグラフで破線が下がっていることに着目してください）。\n",
    "                                                                                                                            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step2:\n",
    "次に、$|s>$ に対する追加の反転 $U_{s}$ を適用します：$U_{s} = 2|s> <s| - 1 $ この変換の結果、状態は $U_{s}|\\psi_{t'}>$ となり、変換 $|\\psi_{t+1}> = U_{s}U_{w}|\\psi_{t}>$ が完了します。（訳注：右側のグラフでwに対応する振幅が増幅されていることに着目してください）。\n",
    "<img src=\"./fig/step2.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "２つの反転は常に回転と対応しています。$ U_{s}U_{w}$ による変換は、初期状態 $|s>$ をアタリ$|w>$ に近づけるような回転となります。（訳注：step 2の左側の図を参照)。$U_{s}$ による反転の効果は、振幅の棒グラフにおいて、平均振幅での反転と解釈できます。最初の反転で平均振幅の値が低くなったので、この変換は、負の振幅をもった $|w>$ をオリジナルの値から大雑把にいって約３倍程度増幅し、他の振幅は小さくします。その後、**Step １** に戻ってこれを繰り返します。アタリ $w$に近くなるまで、この処理を何回か繰り返します。\n",
    "\n",
    "$t$ 回繰り返した後、状態は $|\\psi_{t}> = (U_{s}U_{w})^{t}|\\psi_{0}> $ に変換されます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回転を何回適用する必要があるでしょうか？ おおよそ $\\sqrt N$ 回転で十分なことが分かっています。これは、状態 $|\\psi_{t}>$ の振幅を調べることで明確になります。$|w>$ の振幅が適用回数と共に線型的（$ \\sim tN^{1/2}$）に増えていくことが見てとれます。確率ではなく振幅を扱っているので、ベクトル空間の値には平方根として入ります。そのため、この処理で増幅されるのは、ただの確率ではなく振幅です。\n",
    "\n",
    "もし解が複数、$M$個ある場合、おおよそ$\\sqrt{(N/M)}$ 回転で十分なことが分かっています。\n",
    "\n",
    "<img src=\"./fig/grover_algorithm.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qiskitでの実装: 2量子ビットのGroverのアルゴリズム\n",
    "では、GroverのアルゴリズムをQisKitで実装してみましょう。今回は、2量子ビットを使って、$|11>$を見つけるGroverのアルゴリズムを実装します。\n",
    "\n",
    "最初に環境を準備します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "# importing Qiskit\n",
    "from qiskit import IBMQ, BasicAer\n",
    "from qiskit.providers.ibmq import least_busy\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上のStep1で実施したように求めたい解（今回の場合、$|11>$）の符号を反転するオラクルを作成します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 227.556x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def phase_oracle(circuit, register):\n",
    "    circuit.cz(register[0], register[1])\n",
    "\n",
    "qr = QuantumRegister(2)\n",
    "oracleCircuit = QuantumCircuit(qr)\n",
    "phase_oracle(oracleCircuit, qr)\n",
    "oracleCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "次にStep 2で実施した平均についての反転(inversion about averate)をする回路を作成します。この回路はDiffusion回路と呼ばれることもあります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inversion_about_average(circuit, register):\n",
    "    \"\"\"Apply inversion about the average step of Grover's algorithm.\"\"\"\n",
    "    circuit.h(register)\n",
    "    circuit.x(register)\n",
    "    circuit.h(register[1])\n",
    "    circuit.cx(register[0], register[1])\n",
    "    circuit.h(register[1])\n",
    "    circuit.x(register)\n",
    "    circuit.h(register)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 588.756x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qAverage = QuantumCircuit(qr)\n",
    "inversion_about_average(qAverage, qr)\n",
    "qAverage.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回路の初めで均一な重ね合わせ状態を準備し、今まで作成した部品を合わせ、最後に測定を行います。四つの可能性のうち解は一つなので、繰り返し回数は一回であることに注意してください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 829.556x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(2)\n",
    "cr = ClassicalRegister(2)\n",
    "\n",
    "groverCircuit = QuantumCircuit(qr,cr)\n",
    "groverCircuit.h(qr)\n",
    "\n",
    "phase_oracle(groverCircuit, qr)\n",
    "inversion_about_average(groverCircuit, qr)\n",
    "\n",
    "groverCircuit.measure(qr,cr)\n",
    "groverCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### シミュレーターでの実験\n",
    "上記の回路をシミュレーターで実行してみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('qasm_simulator')\n",
    "shots = 1024\n",
    "results = execute(groverCircuit, backend=backend, shots=shots).result()\n",
    "answer = results.get_counts()\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "実行結果から分かるようにGroverのアルゴリズムは解を発見しています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 実デバイスでの実験\n",
    "以下に示すように、実デバイスで実験を行うこともできます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Least busy backend:  ibmq_ourense\n"
     ]
    }
   ],
   "source": [
    "# Load our saved IBMQ accounts and get the least busy backend device\n",
    "\n",
    "# These are compatible with QisKit v0.11.x\n",
    "#IBMQ.load_accounts()\n",
    "#IBMQ.backends()\n",
    "#backend_lb = least_busy(IBMQ.backends(simulator=False))\n",
    "#print(\"Least busy backend: \", backend_lb)\n",
    "\n",
    "# Updated to run on QisKit v0.12.0\n",
    "IBMQ.load_account()\n",
    "provider = IBMQ.get_provider(group='open')\n",
    "backend_lb = least_busy(provider.backends(simulator=False, operational=True))\n",
    "print(\"Least busy backend: \", backend_lb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "# run our circuit on the least busy backend. Monitor the execution of the job in the queue\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "backend = backend_lb\n",
    "shots = 1024\n",
    "job_exp = execute(groverCircuit, backend=backend, shots=shots)\n",
    "\n",
    "job_monitor(job_exp, interval = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the results from the computation\n",
    "results = job_exp.result()\n",
    "answer = results.get_counts(groverCircuit)\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Qiskitでの実装: 補助量子ビットを用いた2量子ビットのGroverのアルゴリズム\n",
    "同じ$|11>$を見つける2量子ビットのGroverのアルゴリズムですが、今回は求めたい解の符号を反転する際に補助量子ビットを用いた回路を実装しましょう。補助量子ビットを用いることで、量子ビットの数が増えた際や問題が難しい際の複雑なオラクルを実装しやすくなります。\n",
    "\n",
    "最初に環境を準備します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "# importing Qiskit\n",
    "from qiskit import IBMQ, BasicAer\n",
    "from qiskit.providers.ibmq import least_busy\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求めたい解（今回の場合、$|11>$）の符号を反転するオラクルを作成します。但し、今回は補助量子ビットを用いて$|11>$の場合に符号が反転するようにします。この際、正しく符号を反転させるためには事前に補助ビットを$|1>$にする必要があることに注意してください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 408.156x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def phase_oracle(circuit, register,oracle_register):\n",
    "    circuit.h(oracle_register)\n",
    "    circuit.ccx(register[0], register[1],oracle_register)\n",
    "    circuit.h(oracle_register)\n",
    "    \n",
    "qr = QuantumRegister(3)\n",
    "oracleCircuit = QuantumCircuit(qr)\n",
    "oracleCircuit.x(qr[2])\n",
    "phase_oracle(oracleCircuit, qr,qr[2])\n",
    "oracleCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "次に、Diffusion回路を準備します。Diffusion回路は補助ビットには作用しないようにしてください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inversion_about_average(circuit, register):\n",
    "    \"\"\"Apply inversion about the average step of Grover's algorithm.\"\"\"\n",
    "    circuit.h(register)\n",
    "    circuit.x(register)\n",
    "    circuit.h(register[1])\n",
    "    circuit.cx(register[0], register[1])\n",
    "    circuit.h(register[1])\n",
    "    circuit.x(register)\n",
    "    circuit.h(register)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 588.756x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qAverage = QuantumCircuit(qr)\n",
    "inversion_about_average(qAverage, qr[0:2])\n",
    "qAverage.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "補助ビットなしで作成した回路と同じように、回路の最初で均一な重ね合わせ状態を作成し（この際、補助ビットにHゲートをかけないように注意してください）、変換を適用し、最後に測定をします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 889.756x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(3)\n",
    "cr = ClassicalRegister(3)\n",
    "\n",
    "groverCircuit = QuantumCircuit(qr,cr)\n",
    "groverCircuit.h(qr[0:2])\n",
    "groverCircuit.x(qr[2])\n",
    "\n",
    "phase_oracle(groverCircuit, qr,qr[2])\n",
    "inversion_about_average(groverCircuit, qr[0:2])\n",
    "\n",
    "groverCircuit.measure(qr,cr)\n",
    "groverCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### シミュレーターでの実験\n",
    "上記の回路をシミュレーターで実行してみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('qasm_simulator')\n",
    "shots = 1024\n",
    "results = execute(groverCircuit, backend=backend, shots=shots).result()\n",
    "answer = results.get_counts()\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "補助ビットなしで作成した回路と同じように$|11>$の状態の確率が増幅されていることが確認できます。最上位ビットの1は補助量子ビットのものなので無視して問題ありません。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 今週の問題（ラーニングチャレンジ演習 Ⅱ）\n",
    "2量子ビットを使って$|10>$を見つけるGroverのアルゴリズムを実装してみましょう。\n",
    "その際、補助量子ビットを使わないものと使うものの二パターン実装してみましょう。  *ケット内のより上位の量子ビットがQiskit上の量子レジスタのインデックス数が大きいものに対応しています。*\n",
    "\n",
    "シミュレーターでの実行結果から、最も確率が高い量子ビット列とunrollerを用いてu3とCXに分解した結果を提出してください。  \n",
    "\n",
    "作成した量子回路をUnrollerを用いてu3とCXに分解するほうほうについては、[量子回路のコスト計算について](https://github.com/quantum-challenge/2019/blob/master/problems/how_to_calculate_quantum_cost.ipynb)を参照してください。\n",
    "\n",
    "ご自身で実践したラーニングチャレンジの結果ファイルは [提出フォーム](https://angelhack.typeform.com/to/AakobE)から送信をお願いします。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 解答例\n",
    "## 補助量子ビットなし"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "# importing Qiskit\n",
    "from qiskit import IBMQ, BasicAer\n",
    "from qiskit.providers.ibmq import least_busy\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$|10>$の状態の符号を反転するオラクル作成します。このオラクルはCZゲートとXゲートを以下のように組み合わせることにより作成出来ます。$|10>$の状態の符号のみ反転していることを確認してください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 347.956x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def phase_oracle(circuit, register):\n",
    "    circuit.x(register[0])\n",
    "    circuit.cz(register[0], register[1])\n",
    "    circuit.x(register[0])\n",
    "\n",
    "qr = QuantumRegister(2)\n",
    "oracleCircuit = QuantumCircuit(qr)\n",
    "phase_oracle(oracleCircuit, qr)\n",
    "oracleCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inversion_about_average(circuit, register):\n",
    "    \"\"\"Apply inversion about the average step of Grover's algorithm.\"\"\"\n",
    "    circuit.h(register)\n",
    "    circuit.x(register)\n",
    "    circuit.h(register[1])\n",
    "    circuit.cx(register[0], register[1])\n",
    "    circuit.h(register[1])\n",
    "    circuit.x(register)\n",
    "    circuit.h(register)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 889.756x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(2)\n",
    "cr = ClassicalRegister(2)\n",
    "\n",
    "groverCircuit = QuantumCircuit(qr,cr)\n",
    "groverCircuit.h(qr)\n",
    "\n",
    "phase_oracle(groverCircuit, qr)\n",
    "inversion_about_average(groverCircuit, qr)\n",
    "\n",
    "groverCircuit.measure(qr,cr)\n",
    "groverCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('qasm_simulator')\n",
    "shots = 1024\n",
    "results = execute(groverCircuit, backend=backend, shots=shots).result()\n",
    "answer = results.get_counts()\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 補助量子ビットあり"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "# importing Qiskit\n",
    "from qiskit import IBMQ, BasicAer\n",
    "from qiskit.providers.ibmq import least_busy\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
    "\n",
    "# import basic plot tools\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUIAAACoCAYAAACVBefMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAScElEQVR4nO3df1DU953H8ed3+bUIISxCsGr9gQpVIjLStJ4mQTtJo06b6zXa4FxsolKo2plLzLXTZkZO2hQ7DG3V6Y9kprnxJk04kZJr2rN3NUaB1PQi2mSi/UENImAJQesmRfm5+70/qBgC4kL2F/t5PWZ2Rj7fH7z362dffD7fz7JYtm3biIgYzBHqAkREQk1BKCLGUxCKiPEUhCJiPAWhiBhPQSgixlMQiojxFIQiYjwFoYgYT0EoIsZTEIqI8RSEImI8BaGIGE9BKCLGUxCKiPEUhCJiPAWhiBhPQSgixlMQiojxFIQiYjwFoYgYT0EoIsZTEIqI8RSEImI8BaGIGE9BKCLGUxCKiPGiQ12A+Efs4V+F5Pv23bsmJN9Xxi8UfWSy9A+NCEXEeApCETGeglBEjKcgFBHjKQhFxHgKQhExnoJQRIynILyBzZs3Y1kW69atC3UpIhJgekP1KI4cOUJVVRVJSUmhLkUigNcDnWfhvQ6wLHDNgpRZg/+W8KAR4Qd0d3dTXFxMSUkJLpcr1OUEhN3dTf/6Arx1r1xv6+1l4NHHGfjmt7G93hBWF1kunoP6p+DNX8D516D5/+B3B+HVf4eui6Gu7sZM6yNGBKHX66WiooIFCxbgdDpZsmQJtbW1ZGVlUVRUNGzfkpISEhIS2LFjR4iqDTwrPh7HugfwPPc8tm1jezx4ntwNMTFEff1rWA4jukXAXW6DN16A/u6R2666oeE/ofvd4NflC9P6iBFT4y1btlBTU8POnTvJy8vj+PHjbNiwgc7OzmGBd/LkSfbu3UtdXR3R0ZF9aRz3fxZvdQ12/W/wnmjAvniR6IpyrNiYUJcWMc7Wg23fYKMNAz1w/gR87J6gluUzk/pIZL/agcrKSvbv38+xY8fIz88HYNWqVZw6dYqamhqWLl0KwMDAAIWFhRQWFrJs2bJQlhwUVrwTx/oH8FR8D1zJRO/5LlbClFCXFTGuXoZ3L9x8v/YzkLkKHFGBr2m8TOojkTW+HUVZWRmrV68eCsFr5s+fT0xMDDk5OQBUVFTQ0dHB7t27xzxfc3Mz+fn5ZGZmsnjxYurr6wNW+zWWZd30MWE9PUQ9+AWsCd4P9aU2Ex8r7viUT9fP0w+upNSg1DRhH6KPhPr/wVcRHYRtbW2cPn2a9evXj9jW0tJCdnY2cXFxtLS0UFpaSmlpKbZt43a7cbvdeL1e+vv7cbvd9Pf3A1BcXMyDDz5IY2MjTz/9NAUFBfT19QX7qX1o3pdexnugCuu+T+N54efYN5zDyURc6fHt5p/X66G7ryvA1UyMSX0k4oMQYNq0acPau7u7qa2tHZoWNzU10dPTQ1FRES6Xa+jR2trKiy++iMvl4sCBA1y8eJFXXnmFLVu2ALB8+XKmT5/O0aNHA/o8bNu+6WM8vK+dwPODHxL1bzuJ2vZlcLux6yY2svWlNhMff2o9ifNm776yID0zir7+nqDUFIo+Eur/B19F9D3C1NRUABobG1m7du1Qe3l5Oe3t7eTl5QGQm5s7apgVFBSQlZVFaWkpCxcupKWlhfT0dOLi4ob2mTt3LufPnw/wM/Ef75nf4yn7DlFffRxHzmKAwftAP63EuuvOiFsNDBXLgrnL4A+/Hnu/2XcEp57xMLGPRHQQZmRkkJOTQ1lZGSkpKcyYMYPq6moOHToEMBSEycnJrFy5csTxTqeTtLS0oW0XLvhw9zuM2eea8ZTsIqr4SzhWLB9qd9z/mcHVwbp6rJX5Y5xBxmP6Yuh5D879duQ2ywHZayB5RvDrGoupfSSig9DhcHDw4EGKi4vZunUrU6dO5eGHH2b79u088cQTQwslvpo1axYdHR309vYOjQrPnTvH7NmzA1G+31lz5xDzs6qR7U4nMVXPB72eSGdZMO9OuC0L2l6HC28Mts9ZBjNzuPnUOQSsuWb2kYgOQoDMzMwR096NGzeyaNEi4uPjxzy2ubl52NepqamsWLGCZ555hm3btnH8+HEuXLjAqlWr/F22RJBb0mDhvdeDcP6doa1HRor4IBxNQ0PDhN8r+NRTT/HII4+wZ88eYmNjqaysJDY21s8VikgwGReEXV1dNDY2sm3btgkdn5GRQV1dnZ+rEpFQMi4IExMT8Xg8oS5DRMJI5K2Di4iMk4JQRIynIBQR4ykIRcR4CkIRMZ5xq8aRqu/eNaEuQcKc+siNaUQoIsZTEIqI8RSEImI8BaGIGE9BKCLGUxCKiPEUhCJiPAWhiBhPQSgixlMQiojxFIQiYjwFoYgYT0EoIsZTEIqI8RSEImI8BaGIGE9BKCLGUxCKiPEUhCJiPAWhiBhPQSgixlMQiojxFIQiYjwFoYgYT0E4hs2bN2NZFuvWrQt1KTLJ2fbo/5bwEB3qAsLVkSNHqKqqIikpKdSlyCTm6YeWU9D2u+ttv/0PmJUH028HywpdbXKdRoSj6O7upri4mJKSElwuV6jLkUnK0wcnq+Cteujtut5+5RL84X/h9/+j0WG4MCYIvV4vFRUVLFiwAKfTyZIlS6itrSUrK4uioqJh+5aUlJCQkMCOHTtCVK1EgrOvwHvto2z4e/i1n4G/nA5qSXIDxkyNt2zZQk1NDTt37iQvL4/jx4+zYcMGOjs7hwXeyZMn2bt3L3V1dURHG3N5xM8G+uAvb95kJwtaT2mKHA6MeKVXVlayf/9+jh07Rn5+PgCrVq3i1KlT1NTUsHTpUgAGBgYoLCyksLCQZcuWhbLkYSy9Siad2+feyfe31Y+9kw1dnZAYn8TV3r8FpzDD2D7eezBialxWVsbq1auHQvCa+fPnExMTQ05ODgAVFRV0dHSwe/fuMc9XUlJCZmYmDoeD6urqgNUtk5fDivJ9X4fv+0pgRPyIsK2tjdOnT/PYY4+N2NbS0kJ2djZxcXG0tLRQWlrKvn37sG0bt9sNDN5b7O/vx+12k5CQQExMDKtXr+aRRx5h8+bNQXkOvv5Uk/DRdxXqnwLbO/Z+ziR478plTY1DLOJHhG1tbQBMmzZtWHt3dze1tbVD0+KmpiZ6enooKirC5XINPVpbW3nxxRdxuVwcOHAAgOXLl5ORkRHcJyKTSuwUSP8YcJOAm5mr+4PhIOJHhKmpqQA0Njaydu3aofby8nLa29vJy8sDIDc3l6NHj444vqCggKysLEpLS1m4cGFwipaIsCAf3K3Q08XQSvH7Jc+Ajy4NelkyiogPwoyMDHJycigrKyMlJYUZM2ZQXV3NoUOHAIaCMDk5mZUrV4443ul0kpaWNuo2kbHEJcAdD8HZWnj7j9enyVGxMDMHMlZAVMS/AieHiJ8aOxwODh48SHZ2Nlu3bmXTpk2kpqayfft2oqKihhZKRAIhLgGy18JdW6+33b0VFqyEqJiQlSUfYMTPo8zMzBHT3o0bN7Jo0SLi4+PHPLa5uTmAlYkpYt/XzRSA4SfiR4Q30tDQMDQtHq+dO3cyc+ZMXn31VYqLi5k5cyZvvfWWnysUkWAxMgi7urpobGwcWjEer29961u0tbXR29vLpUuXaGtrY968eX6uUkSCxYip8QclJibi8XhCXYaIhAkjR4QiIu+nIBQR4ykIRcR4CkIRMZ6CUESMpyAUEeMpCEXEeApCETGeglBEjKcgFBHjKQhFxHgKQhExnoJQRIynIBQR4ykIRcR4CkIRMZ6CUESMpyAUEeMpCEXEeApCETGeglBEjGfkX7GLRLGHfxWS79t375oPdfyjz/mpkHHY88/B/57hQNf6xjQiFBHjKQhFxHiaGosEiO2FS+fB3QZ/67je/sZ/wS3pMHU2JH0ELCt0NcogBaGIn9leaH0dWhqg572R2zvPDj6afgOJt8HcT0J6VvDrlOsUhCJ+dPUynDkE77b7tn/XO/DmL6DjT7DwXoiJD2x9MjoFoYifdHXCySro7x7/se80wpW/Qt4XIHaK/2uTsWmxRMQP+q7CqeqJheA1Vy7C6zXg9fivLvGNgnAMmzdvxrIs1q1bF+pSJMz98SXouzL2Pvf86+BjLO+9DedP+K8u8Y2C8AaOHDlCVVUVSUlJoS5Fwtzl1sGprb80vQq9NwlV8S8F4Si6u7spLi6mpKQEl8sV6nL8zu7upn99Ad66V6639fYy8OjjDHzz29hebwirG9tPvjKd00d/MqzNtm1+XJjE2RMvhKSmttf9ez7bA39507/nnIhwvNaBYkwQer1eKioqWLBgAU6nkyVLllBbW0tWVhZFRUXD9i0pKSEhIYEdO3aEqNrAsuLjcax7AM9zz2PbNrbHg+fJ3RATQ9TXv4blCM9u0fXXC1xxt5M2O3dY+7vvNNHX8zfSMz4e9Jo8/fDOn/1/3rf/4P9zjkc4XutAMmbVeMuWLdTU1LBz507y8vI4fvw4GzZsoLOzc1jgnTx5kr1791JXV0d0dOReHsf9n8VbXYNd/xu8JxqwL14kuqIcKzYm1KXdUEfTCSxHFFNn3j6s/WLLG0y5NZ1bpn406DV1dQ6+b9DfrlyCgT6IjvX/uX0Rjtc6kCL3lf4+lZWV7N+/n2PHjpGfnw/AqlWrOHXqFDU1NSxduhSAgYEBCgsLKSwsZNmyZaEsOeCseCeO9Q/gqfgeuJKJ3vNdrITwft9GR9MJXNMyiY51DmvvbHmD2+aGZoTSdSlw575yCW79SODOP5ZwvNaBZEQQlpWVsXr16qEQvGb+/PnExMSQk5MDQEVFBR0dHezevfuG57p8+TIbN26ksbGR+Ph40tPT+dGPfsT8+fMDVr/lw+9gxfz60MRO3tND1INfwJrgvVBfahvLv/zU9nnfjqYTuDvO8vSXU4e19/d28fHPfsPn83zYmt/vH5dv5yv/9INhbTdbGb7R9pcqhn9914q7efNc/YeobrjJfq0nwrZ9e84RH4RtbW2cPn2axx57bMS2lpYWsrOziYuLo6WlhdLSUvbt24dt27jdbmDw3mJ/fz9ut5uEhAQsy+LRRx/lnnvuAWDfvn1s2rSJ+nr/ddhg8L70Mt4DVVj3fRrPCz/HWnNfyDvtzXSca+CTn9/Fwju/OKz9uW8sJj1Eo5S+gZ5Jee6bCcdrHUhGBCHAtGnThrV3d3dTW1vLmjWDn6fX1NRET08PRUVFIxZPWltbcblcPPvsszz00ENDIQiwfPlyysvLA/ocfPmpNp7PI/S+dgLPD35I1Dd3YS1YwMAXN2HX1WPl3x2Q2sbi62fkud8+S++Vy8zOuY9bps4c3n7VTXrGHT5/zw9b87C6LkBD5fC2D47srrk2ErzR9g86/efXiI6beG0fNNmvdSBFfBCmpg4O7RsbG1m7du1Qe3l5Oe3t7eTl5QGQm5vL0aNHRxxfUFBAVlYWpaWlLFy4cMT2PXv28LnPfS5A1fuf98zv8ZR9h6ivPo4jZzHA4L3Cn1Zi3XVn2K4YdzSdIDpuCmmzlgxrb//zcRKnfpQpt94WkrpuSRv89Bh/v96npODXEByPcL3WgRTxQZiRkUFOTg5lZWWkpKQwY8YMqqurOXRo8J7atSBMTk5m5cqVI453Op2kpaWNuq20tJSzZ8/y8ssvB/Ip+I19rhlPyS6iir+EY8XyoXbH/Z8ZXEGuq8damT/GGUKno+kE6XPvwBE1vMu2n301pFO1qFhInTf4aTL+FMpPownXax1IER+EDoeDgwcPUlxczNatW5k6dSoPP/ww27dv54knnhhaKBmvJ598kl/+8pccPnyYKVPCe7X1GmvuHGJ+VjWy3ekkpur5oNczHnc/9L1R2z+16cdBrmSkmbl+DkILZkysW/pFOF/rQIn4IATIzMwcMe3duHEjixYtIj5+7M89am5uHtFWWlrKoUOHOHz4MMnJyf4sVSahlNmQmgEXm/xzvjmfAOct/jmX+MaIIBxNQ0PDhN4reObMGXbt2sW8efOGTZdff93Pv2clk4ZlwcJPw2/3Q/8YC72+LJIkpkHGP/itNPGRkUHY1dVFY2Mj27ZtG/ex2dnZk2YlTIInLhFyH4DfVcNA78TOEZ8MuZ8Hh5GvytAy8pInJibi8ehD38S/bv0IfLwATv83dF0c37EpcyB7DcQlBKQ0uQkjg1AkUBLT4BMbofk1aD118w9qjU+GOZ+E6bfrjziFkoJQxM8cUYP3+ebcAe+c/ftfsXtn8FOsLWtwGp2UPrjIkjJHARgOFIQiAeKIhmkfG3xIeAvPXyMQEQkiBaGIGM+y9V4QETGcRoQiYjwFoYgYT0EoIsZTEIqI8RSEImI8BaGIGE9BKCLGUxCKiPEUhCJiPAWhiBhPQSgixlMQiojxFIQiYjwFoYgYT0EoIsZTEIqI8RSEImI8BaGIGE9BKCLG+3+ZIFsH2KNjNQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 408.156x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def phase_oracle(circuit, register,oracle_register):\n",
    "    circuit.h(oracle_register)\n",
    "    circuit.x(register[0])\n",
    "    circuit.ccx(register[0], register[1],oracle_register)\n",
    "    circuit.x(register[0])\n",
    "    circuit.h(oracle_register)\n",
    "\n",
    "qr = QuantumRegister(3)\n",
    "oracleCircuit = QuantumCircuit(qr)\n",
    "oracleCircuit.x(qr[2])\n",
    "phase_oracle(oracleCircuit, qr,qr[2])\n",
    "oracleCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inversion_about_average(circuit, register):\n",
    "    \"\"\"Apply inversion about the average step of Grover's algorithm.\"\"\"\n",
    "    circuit.h(register)\n",
    "    circuit.x(register)\n",
    "    circuit.h(register[1])\n",
    "    circuit.cx(register[0], register[1])\n",
    "    circuit.h(register[1])\n",
    "    circuit.x(register)\n",
    "    circuit.h(register)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 889.756x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(3)\n",
    "cr = ClassicalRegister(3)\n",
    "\n",
    "groverCircuit = QuantumCircuit(qr,cr)\n",
    "groverCircuit.h(qr[0:2])\n",
    "groverCircuit.x(qr[2])\n",
    "\n",
    "phase_oracle(groverCircuit, qr,qr[2])\n",
    "inversion_about_average(groverCircuit, qr[0:2])\n",
    "\n",
    "groverCircuit.measure(qr,cr)\n",
    "groverCircuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('qasm_simulator')\n",
    "shots = 1024\n",
    "results = execute(groverCircuit, backend=backend, shots=shots).result()\n",
    "answer = results.get_counts()\n",
    "plot_histogram(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "正しく$|10>$の状態の確率が増幅されています（最上位の量子ビットは補助量子ビットのため、無視して問題ありません）。"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}