{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "68fa4eaf",
   "metadata": {},
   "source": [
    "# CHSH不等式の破れを確認する"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd229f9",
   "metadata": {},
   "source": [
    "この最初の実習では、量子コンピュータにおいて量子力学的状態、特に「**エンタングルメント**」が実現しているか検証してみましょう。実習を通じて量子力学の概念と量子コンピューティングの基礎を紹介していきます。\n",
    "\n",
    "```{contents} 目次\n",
    "---\n",
    "local: true\n",
    "---\n",
    "```\n",
    "\n",
    "$\\newcommand{\\ket}[1]{|#1\\rangle}$\n",
    "$\\newcommand{\\rmI}{\\mathrm{I}}$\n",
    "$\\newcommand{\\rmII}{\\mathrm{II}}$\n",
    "$\\newcommand{\\rmIII}{\\mathrm{III}}$\n",
    "$\\newcommand{\\rmIV}{\\mathrm{IV}}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91104536",
   "metadata": {},
   "source": [
    "## 本当に量子コンピュータなのか？\n",
    "\n",
    "このワークブックの主旨が量子コンピュータ（QC）を使おう、ということですが、QCなんて数年前までSFの世界の存在でした。それが今やクラウドの計算リソースとして使えるというわけですが、ではそもそも私たちがこれから使おうとしている機械は本当にQCなのでしょうか。どうしたらそれが調べられるでしょうか。\n",
    "\n",
    "QCの基本的な仕組みは、「何らかの物理的な系（超電導共振器や冷却原子など）をうまく操作して、求める計算の結果がその系の量子状態に表現されるようにする」ということです。つまり、量子状態が長く保たれてかつ思うように操作できる対象と、「計算」という実体のなさそうなものを具体的な「量子操作」に対応させるアルゴリズムの両方があって初めてQCが成り立ちます。アルゴリズムの部分はこのワークブックを通じて少しずつ紹介していくので、今回は「量子状態が保たれ、それを操作できる」ということを確認してみましょう。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "226c05b7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "## CHSH不等式\n",
    "\n",
    "量子力学的状態が実際に存在するかどうかを確かめる実験として、2022年のノーベル物理学賞でも取り上げられたCHSH不等式{cite}`chsh`の検証というものがあります。かいつまんで言うと、CHSH不等式とは「二体系の特定の観測量について、エンタングルメントなど量子力学固有の現象がなければ保たれる不等式」です。やや回りくどいロジックですが、つまりQC（だと考えられる機械）で測ったこの観測量の値がCHSH不等式を破っていれば、その機械は実際に量子現象を利用しているかもしれないということになります。\n",
    "\n",
    "通常このような実験を行うには高度なセットアップ（レーザーと非線形結晶、冷却原子など）が必要ですが、クラウドQCではブラウザひとつしか要りません。このワークブックではJupyter NotebookでPythonのプログラムを書き、<a href=\"https://quantum.ibm.com\" target=\"_blank\">IBM Quantum</a>の量子コンピュータを利用します。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "563a3151",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "## Qiskitの基本構造\n",
    "\n",
    "IBM QuantumのQCで量子計算を実行するには、IBMの提供する<a href=\"https://www.ibm.com/quantum/qiskit\" target=\"_blank\">Qiskit</a>というPythonライブラリを利用します。Qiskitの基本的な使い方は\n",
    "\n",
    "1. 使用する量子ビットの数を決め、量子計算の操作（ゲート）をかけて、量子回路を作る\n",
    "1. 回路を実行して計算結果を得る。ここでは二通りのオプションがあり、\n",
    "   - 回路をQCの実機に送り、実行させる。\n",
    "   - 回路をシミュレートする。\n",
    "1. 計算結果を解析する。\n",
    "\n",
    "です。以下でこの流れを一通り、重要な概念の説明を混ぜながら実行してみましょう。ただし、今回は実機のみ利用します。回路のシミュレーションに関しては{doc}`第一回の課題 <nonlocal_correlations>`を参照してください。\n",
    "\n",
    "Qiskitの機能は上のような基本的な量子回路の設計・実行だけではなく、非常に多岐に渡ります。基本的な使い方に関しても多少複雑なところがあるので、わからないことがあれば<a href=\"https://docs.quantum.ibm.com/\" target=\"_blank\">Qiskitのドキュメンテーション</a>をあたってみましょう。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b802069c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "### 量子ビット、量子レジスタ\n",
    "\n",
    "**量子ビット**（qubit=キュビット）とは量子コンピュータの基本構成要素のことで、量子情報の入れ物の最小単位です。そして、量子ビットの集まりを量子レジスタと呼びます。\n",
    "\n",
    "量子レジスタは量子コンピュータ中で常に一つの「状態」にあります。量子レジスタの状態を物理学の習わしに従ってしばしば「ケット」という$\\ket{\\psi}$のような記号で表します[^mixed_state]。量子力学に不慣れな方はこの記法で怯んでしまうかもしれませんが、ケット自体はただの記号なのであまり気にしないでください。別に「枠」なしで$\\psi$と書いても、絵文字を使って🔱と書いても、何でも構いません。\n",
    "\n",
    "重要なのは各量子ビットに対して2つの**基底状態**が定義できることで、量子計算の習わしではそれらを$\\ket{0}$と$\\ket{1}$で表し、「計算基底」とも呼びます[^basis]。そして、量子ビットの任意の状態は、2つの複素数$\\alpha, \\beta$を使って\n",
    "\n",
    "$$\n",
    "\\alpha \\ket{0} + \\beta \\ket{1}\n",
    "$$\n",
    "\n",
    "と2つの基底の「重ね合わせ」で表せます。ここで$\\alpha, \\beta$を確率振幅、もしくは単に**振幅**（amplitude）と呼びます。繰り返しですが別に表記法自体に深い意味はなく、例えば同じ状態を$[\\alpha, \\beta]$と書いてもいいわけです[^complexarray]。\n",
    "\n",
    "量子ビットの任意の状態が2つの複素数で表せるということは、逆に言えば一つの量子ビットには2つの複素数に相当する情報を記録できるということになります。ただこれには少し注釈があって、量子力学の決まりごとから、$\\alpha$と$\\beta$は\n",
    "\n",
    "$$\n",
    "|\\alpha|^2 + |\\beta|^2 = 1\n",
    "$$\n",
    "\n",
    "という関係を満たさなければならず、かつ全体の位相（global phase）は意味を持たない、つまり、任意の実数$\\theta$に対して\n",
    "\n",
    "$$\n",
    "\\alpha \\ket{0} + \\beta \\ket{1} \\sim e^{i\\theta} (\\alpha \\ket{0} + \\beta \\ket{1})\n",
    "$$\n",
    "\n",
    "（ここで $\\sim$ は「同じ量子状態を表す」という意味）である、という制約があります。\n",
    "\n",
    "複素数1つは実数2つで書けるので、$\\alpha$と$\\beta$をあわせて実数4つ分の情報が入っているようですが、2つの拘束条件があるため、実際の自由度は 4-2=2 個です。自由度の数をあらわにして量子ビットの状態を記述するときは、\n",
    "\n",
    "$$\n",
    "e^{-i\\phi/2}\\cos\\frac{\\theta}{2}\\ket{0} + e^{i\\phi/2}\\sin\\frac{\\theta}{2}\\ket{1}\n",
    "$$\n",
    "\n",
    "と書いたりもします。この表記法をブロッホ球表現と呼ぶこともあります。\n",
    "\n",
    "面白くなるのは量子ビットが複数ある場合です。例えば量子ビット2つなら、それぞれに$\\ket{0}, \\ket{1}$の計算基底があるので、任意の状態は\n",
    "\n",
    "$$\n",
    "\\alpha \\ket{0}\\ket{0} + \\beta \\ket{0}\\ket{1} + \\gamma \\ket{1}\\ket{0} + \\delta \\ket{1}\\ket{1}\n",
    "$$\n",
    "\n",
    "と4つの複素数を使った重ね合わせになります。2つの量子ビットの基底を並べた$\\ket{0}\\ket{0}$のような状態が、このレジスタの計算基底ということになります。$\\ket{00}$と略したりもします。\n",
    "\n",
    "上で登場した量子力学の決まりごとはこの場合\n",
    "\n",
    "$$\n",
    "|\\alpha|^2 + |\\beta|^2 + |\\gamma|^2 + |\\delta|^2 = 1\n",
    "$$\n",
    "\n",
    "と\n",
    "\n",
    "$$\n",
    "\\alpha \\ket{00} + \\beta \\ket{01} + \\gamma \\ket{10} + \\delta \\ket{11} \\sim e^{i\\theta} (\\alpha \\ket{00} + \\beta \\ket{01} + \\gamma \\ket{10} + \\delta \\ket{11})\n",
    "$$\n",
    "\n",
    "となります。量子ビットがいくつあっても拘束条件は2つだけです。\n",
    "\n",
    "つまり、量子ビット$n$個のレジスタでは、基底の数が$2^n$個で、それぞれに複素数の振幅がかかるので、実数$2 \\times 2^n - 2$個分の情報が記録できることになります。これが量子計算に関して「指数関数的」という表現がよく用いられる所以です。\n",
    "\n",
    "量子レジスタの計算基底状態の表記法としては、上に書いたようにケットを$n$個並べたり$n$個の0/1を一つのケットの中に並べたりする方法がありますが、さらにコンパクトなのが、0/1の並び（ビット列）を二進数とみなして、対応する（十進数の）数字で表現する方法です。例えば4量子ビットのレジスタで状態$\\ket{0000}$と$\\ket{1111}$はそれぞれ$\\ket{0}$と$\\ket{15}$と書けます。\n",
    "\n",
    "ただし、ここで注意すべきなのは、左右端のどちらが「1の位」なのか事前に約束しないといけないことです。$\\ket{0100}$を$\\ket{4}$（右端が1の位）とするか$\\ket{2}$（左端が1の位）とするかは約束次第です。このワークブックでは、Qiskitでの定義に従って、右端を1の位とします。同時に、レジスタの最初の量子ビットが1の位に対応するようにしたいので、ケットや0/1を並べて計算基底を表現するときは、右から順にレジスタの量子ビットを並べていくことにします。\n",
    "\n",
    "Qiskitには量子レジスタオブジェクトがあり、\n",
    "```{code-block} python\n",
    "from qiskit import QuantumRegister\n",
    "register = QuantumRegister(4, 'myregister')\n",
    "```\n",
    "のように量子ビット数（この場合4）と名前（`'myregister'`）を指定して初期化します。初期状態では、量子ビットはすべて$\\ket{0}$状態にあります。レジスタオブジェクトはこのままではあまり使い道がなく、基本的には次に紹介する量子回路の一部として利用します。\n",
    "\n",
    "[^mixed_state]: 正確には、状態がケットで表せるのはこのレジスタが他のレジスタとエンタングルしていないときに限られますが、ここでは詳細を割愛します。\n",
    "[^basis]: ここで言う「基底」は線形代数での意味（basis）で、「線形空間中の任意のベクトルを要素の線形和で表せる最小の集合」です。基底となる量子状態だから「基底状態」と呼びます。化学や量子力学で言うところのエネルギーの最も低い状態「基底状態」（ground state）とは関係ありません。\n",
    "[^complexarray]: 実際に量子計算のシミュレーションをコンピュータ上で行う時などは、量子レジスタの状態を複素数の配列で表すので、この表記の方がよく対応します。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "805766df",
   "metadata": {},
   "source": [
    "### ゲート、回路、測定\n",
    "\n",
    "量子計算とは、端的に言えば、量子レジスタに特定の状態を生成し、その振幅を利用することと言えます。\n",
    "\n",
    "とは言っても、いきなり「えいや」と好きな量子状態を作れるわけではなく、パターンの決まった単純操作（$\\ket{0}$と$\\ket{1}$を入れ替える、ブロッホ球表現での位相角度$\\phi$を増減させる、など）を順番に組み合わせて複雑な状態を作っていきます。この単純操作のオペレーションのことを一般に量子**ゲート**といい、ゲートの種類や順番を指定したプログラムに相当するものを量子**回路**と呼びます。\n",
    "\n",
    "Qiskitでは、量子回路を`QuantumCircuit`オブジェクトで表します。\n",
    "```{code-block} python\n",
    "from qiskit import QuantumCircuit, QuantumRegister\n",
    "register = QuantumRegister(4, 'myregister')\n",
    "circuit = QuantumCircuit(register)\n",
    "```\n",
    "という具合です。\n",
    "\n",
    "作られた量子回路は、量子ビットの数が決まっているもののゲートが一つもない「空っぽ」の状態なので、そこにゲートをかけていきます。例えば下で説明するアダマールゲートをレジスタの2個目の量子ビットに作用させるには\n",
    "```{code-block} python\n",
    "circuit.h(register[1])\n",
    "```\n",
    "とします。\n",
    "\n",
    "上で「振幅を利用する」という曖昧な表現をしましたが、それはいろいろな利用の仕方があるからです。しかし、どんな方法であっても、必ず量子レジスタの**測定**という操作を行います。量子コンピュータから何かしらの情報を得るための唯一の方法が測定です。Qiskitでは`measure_all`というメソッドを使って測定を行います。\n",
    "```{code-block} python\n",
    "circuit.measure_all()\n",
    "```\n",
    "\n",
    "測定は量子レジスタの状態を「覗き見る」ような操作ですが、一回の測定操作で具体的に起きることは、各量子ビットに対して0もしくは1という値が得られるというだけです。つまり、量子状態が$2^n$個の計算基底の複雑な重ね合わせであったとしても、測定をすると一つの計算基底に対応するビット列が出てくるだけということになります。しかも、一度測定してしまった量子ビットはもう状態を変えてしまっていて、複雑な重ね合わせは失われてしまいます。\n",
    "\n",
    "ではこの「一つの計算基底」がどの基底なのかというと、実は特殊な場合を除いて決まっていません。全く同じ回路を繰り返し実行して測定すると、毎回ランダムにビット列が決まります。ただし、このランダムさには法則があって、**特定のビット列が得られる確率は、対応する計算基底の振幅の絶対値自乗**となっています。つまり、$n$ビットレジスタの状態$\\sum_{j=0}^{2^n-1} c_j \\ket{j}$があるとき、測定でビット列$k$が得られる確率は$|c_k|^2$です。根本的には、この確率の分布$|c_0|^2, |c_1|^2, \\dots, |c_{2^n-1}|^2$こそが量子計算の結果です。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb12ad5",
   "metadata": {},
   "source": [
    "### 量子計算結果の解析\n",
    "\n",
    "回路の実行と測定を何度も繰り返して、それぞれのビット列が現れる頻度を記録すれば、だんだん$|c_j|^2$の値がわかっていきます。例えば、2量子ビットの回路を1000回実行・測定して、ビット列00、01、10、11がそれぞれ246回、300回、103回、351回得られたとすれば、統計誤差を考慮して$|c_0|^2=0.24 \\pm 0.01$、$|c_1|^2=0.30 \\pm 0.01$、$|c_2|^2=0.11 \\pm 0.01$、$|c_3|^2=0.35 \\pm 0.01$という具合です。しかし、わかるのは$c_j$の絶対値だけで、複素位相については知る術なしです。どうもすっきりしませんが、これが量子コンピュータから情報を得る方法です。\n",
    "\n",
    "逆に、指数関数的な内部の情報量をうまく使って計算を行いつつ、測定という限定的な方法でも答えが読み出せるように工夫するのが、量子アルゴリズム設計の真髄ということになります。例えば理想的には、何か計算の答えが整数$k$であり、それを計算する回路の終状態が単純に$\\ket{k}$となるようであれば、一度の測定で答えがわかる（上でいった特殊な場合に相当）わけです。単純に$\\ket{k}$でなくても、重ね合わせ$\\sum_{j=0}^{2^n-1} c_j \\ket{j}$において$|c_k| \\gg |c_{j \\neq k}|$を実現できれば、数回の測定で答えが高確率でわかります。{doc}`shor`で紹介する位相推定アルゴリズムはその好例です。\n",
    "\n",
    "一度の測定で答えがわかるケースを除いて、基本的には多数回の試行から確率分布を推定することになるので、量子回路を量子コンピュータの実機やシミュレータに送って実行させる時には必ず繰り返し数（「ショット数」と呼びます）を指定します。ショット数$S$でビット列$k$が$n_k$回得られた時、$|c_k|^2$の推定値は$z_k = n_k/S$、その統計誤差は（$S, n_k, S-n_k$が全て十分大きい場合）$\\sqrt{z_k (1-z_k) / S}$で与えられます。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19fc77b0",
   "metadata": {},
   "source": [
    "(common_gates)=\n",
    "### よく使うゲート\n",
    "\n",
    "IBM Q System Oneのような超電導振動子を利用した量子コンピュータでは、実際に使用できるゲートは量子ビット1つにかかるものと2つにかかるものに限定されます。しかし、それらを十分な数組み合わせれば、$n$量子ビットレジスタにおいてどのような状態も実現できることが、数学的に証明されています。\n",
    "\n",
    "#### 1量子ビットの操作\n",
    "\n",
    "1量子ビットの操作でよく使われるゲートには、以下のようなものがあります。（表中コードの`i`, `j`は量子ビットの番号）\n",
    "\n",
    "```{list-table}\n",
    ":header-rows: 1\n",
    "* - ゲート名\n",
    "  - 説明\n",
    "  - Qiskitコード\n",
    "* - $X$\n",
    "  - $\\ket{0}$と$\\ket{1}$を入れ替える。\n",
    "  - `circuit.x(i)`\n",
    "* - $Z$\n",
    "  - $\\ket{1}$の振幅を$-1$倍する。\n",
    "  - `circuit.z(i)`\n",
    "* - $H$（アダマールゲート）\n",
    "  - 計算基底それぞれに対して、以下の変形をする。\n",
    "    ```{math}\n",
    "    H\\ket{0} = \\frac{1}{\\sqrt{2}} (\\ket{0} + \\ket{1}) \\\\\n",
    "    H\\ket{1} = \\frac{1}{\\sqrt{2}} (\\ket{0} - \\ket{1})\n",
    "    ```\n",
    "    （「量子状態にゲートを作用させる」ことをケットの記法で書くときは、ゲートに対応する記号をケットに左からかけます。）<br/>\n",
    "    例えば状態$\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$に対しては、\n",
    "    ```{math}\n",
    "    \\begin{align}\n",
    "    H\\ket{\\psi} & = \\alpha \\frac{1}{\\sqrt{2}} (\\ket{0} + \\ket{1}) + \\beta \\frac{1}{\\sqrt{2}} (\\ket{0} - \\ket{1}) \\\\\n",
    "                & = \\frac{1}{\\sqrt{2}} (\\alpha + \\beta) \\ket{0} + \\frac{1}{\\sqrt{2}} (\\alpha - \\beta) \\ket{1}\n",
    "    \\end{align}\n",
    "    ```\n",
    "    となる。\n",
    "  - `circuit.h(i)`\n",
    "* - $R_{y}$\n",
    "  - パラメータ$\\theta$を取り、計算基底それぞれに対して、以下の変形をする。\n",
    "    ```{math}\n",
    "    R_{y}(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} + \\sin\\frac{\\theta}{2}\\ket{1} \\\\\n",
    "    R_{y}(\\theta)\\ket{1} = -\\sin\\frac{\\theta}{2}\\ket{0} + \\cos\\frac{\\theta}{2}\\ket{1}\n",
    "    ```\n",
    "  - `circuit.ry(theta, i)`\n",
    "* - $R_{z}$\n",
    "  - パラメータ$\\phi$を取り、計算基底それぞれに対して、以下の変形をする。\n",
    "    ```{math}\n",
    "    R_{z}(\\phi)\\ket{0} = e^{-i\\phi/2}\\ket{0} \\\\\n",
    "    R_{z}(\\phi)\\ket{1} = e^{i\\phi/2}\\ket{1}\n",
    "  - `circuit.rz(phi, i)`\n",
    "```\n",
    "\n",
    "それでは、2量子ビットレジスタの第0ビットに$H, R_y, X$の順にゲートをかけて、最後に測定をする回路をQiskitで書いてみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1885635b",
   "metadata": {
    "tags": [
     "remove-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notebook ready\n"
     ]
    }
   ],
   "source": [
    "# First, import all the necessary python modules\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit import QuantumCircuit, transpile\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler\n",
    "from qiskit_ibm_runtime.accounts import AccountNotFoundError\n",
    "# qc_workbook is the original module written for this workbook\n",
    "# If you encounter an ImportError, edit the environment variable PYTHONPATH or sys.path\n",
    "from qc_workbook.utils import operational_backend\n",
    "\n",
    "print('notebook ready')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d621afda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This circuit has 2 qubits and 5 operations\n"
     ]
    }
   ],
   "source": [
    "circuit = QuantumCircuit(2) # You can also create a circuit by specifying the number of bits, without using a register\n",
    "circuit.h(0) # In that case, directly specify the number of the quantum bit for the gate, not register[0]\n",
    "circuit.ry(np.pi / 2., 0) #　θ = π/2\n",
    "circuit.x(0)\n",
    "# Measurement is always needed to get an output\n",
    "circuit.measure_all()\n",
    "\n",
    "print(f'This circuit has {circuit.num_qubits} qubits and {circuit.size()} operations')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c60896ae",
   "metadata": {},
   "source": [
    "最後のプリント文で、ゲートが3つなのにも関わらず \"5 operations\" と出てくるのは、各量子ビットの測定も一つのオペレーションとして数えられるからです。\n",
    "\n",
    "量子計算に慣れる目的で、この$H, R_y(\\pi/2), X$という順の操作で第0ビットに何が起こるかを辿ってみましょう。初期状態は$\\ket{0}$で、ケット記法では操作は左からかけていく（ゲート操作が右から順に並ぶ）ので、$X R_y(\\pi/2) H \\ket{0}$を計算することになります。\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "X R_y\\left(\\frac{\\pi}{2}\\right) H \\ket{0} & = X R_y\\left(\\frac{\\pi}{2}\\right) \\frac{1}{\\sqrt{2}}(\\ket{0} + \\ket{1}) \\\\\n",
    "& = \\frac{1}{\\sqrt{2}} X \\left[\\left(\\cos\\left(\\frac{\\pi}{4}\\right)\\ket{0} + \\sin\\left(\\frac{\\pi}{4}\\right)\\ket{1}\\right) + \\left(-\\sin\\left(\\frac{\\pi}{4}\\right)\\ket{0} + \\cos\\left(\\frac{\\pi}{4}\\right)\\ket{1}\\right)\\right] \\\\\n",
    "& = \\frac{1}{\\sqrt{2}} X \\frac{1}{\\sqrt{2}} \\left[\\left(\\ket{0} + \\ket{1}\\right) + \\left(-\\ket{0} + \\ket{1}\\right)\\right] \\\\\n",
    "& = X \\ket{1} \\\\\n",
    "& = \\ket{0}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "なので、結局$\\ket{0}$状態に戻る操作でした。\n",
    "\n",
    "#### 2量子ビットの操作\n",
    "\n",
    "2量子ビットの操作は、量子ビットの超電導素子での実装の都合上、全て「制御ゲート」（controlled gates）という方式で行われます。この方式では、2つのビットのうち片方を制御（control）、もう片方を標的（target）として、制御ビットが1の時だけ標的ビットに何らかの操作がかかります。\n",
    "\n",
    "例として、任意の1ビットゲート$U$を制御ゲート化した$C^i_j[U]$を考えます。ここで$i$が制御、$j$が標的ビットとします。ケットの添字でビットの番号を表して（reminder: 並べて書くときは右から順に番号を振ります）\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "C^i_j[U](\\ket{0}_i\\ket{0}_j) & = \\ket{0}_i\\ket{0}_j \\\\\n",
    "C^i_j[U](\\ket{0}_i\\ket{1}_j) & = \\ket{0}_i\\ket{1}_j \\\\\n",
    "C^i_j[U](\\ket{1}_i\\ket{0}_j) & = \\ket{1}_iU\\ket{0}_j \\\\\n",
    "C^i_j[U](\\ket{1}_i\\ket{1}_j) & = \\ket{1}_iU\\ket{1}_j\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "です。\n",
    "\n",
    "上で紹介した頻出する1ビットゲート$X, Z, H, R_y, R_z$のうち、$H$以外は制御ゲート化バージョンもよく使われます。特に$C[X]$はCXやCNOTとも呼ばれ、量子計算の基本要素として多様されます。実際、全ての2量子ビット制御ゲートはCNOTと1量子ビットゲートの組み合わせに分解できます。\n",
    "\n",
    "```{list-table}\n",
    ":header-rows: 1\n",
    "* - ゲート名\n",
    "  - 説明\n",
    "  - Qiskitコード\n",
    "* - $C^i_j[X]$, CX, CNOT\n",
    "  - ビット$i$が1である計算基底において、ビット$j$に$X$を作用させる。\n",
    "  - `circuit.cx(i, j)`\n",
    "* - $C^i_j[Z]$\n",
    "  - ビット$i, j$が1である計算基底の符号を反転させる。\n",
    "  - `circuit.cz(i, j)`\n",
    "* - $C^i_j[R_{y}]$\n",
    "  - パラメータ$\\theta$を取り、ビット$i$が1である計算基底において、ビット$j$に$R_y$を作用させる。\n",
    "  - `circuit.cry(theta, i, j)`\n",
    "* - $C^i_j[R_{z}]$\n",
    "  - パラメータ$\\phi$を取り、ビット$i$が1である計算基底において、ビット$j$に$R_z$を作用させる。\n",
    "  - `circuit.crz(phi, i, j)`\n",
    "```\n",
    "\n",
    "Qiskitで2ビットレジスタに制御ゲートを用い、計算基底$\\ket{0}, \\ket{1}, \\ket{2}, \\ket{3}$の振幅の絶対値自乗が$1:2:3:4$の比になるような状態を作ってみましょう。さらに$C^0_1[Z]$ゲートを使って$\\ket{3}$だけ振幅の符号が他と異なるようにします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "65de057a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This circuit has 2 qubits and 6 operations\n"
     ]
    }
   ],
   "source": [
    "theta1 = 2. * np.arctan(np.sqrt(7. / 3.))\n",
    "theta2 = 2. * np.arctan(np.sqrt(2.))\n",
    "theta3 = 2. * np.arctan(np.sqrt(4. / 3))\n",
    "\n",
    "circuit = QuantumCircuit(2)\n",
    "circuit.ry(theta1, 1)\n",
    "circuit.ry(theta2, 0)\n",
    "circuit.cry(theta3 - theta2, 1, 0) # C[Ry]　1が制御で0が標的\n",
    "circuit.cz(0, 1) # C[Z] 0が制御で1が標的（実はC[Z]ではどちらが制御でも結果は同じ）\n",
    "circuit.measure_all()\n",
    "\n",
    "print(f'This circuit has {circuit.num_qubits} qubits and {circuit.size()} operations')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e546901",
   "metadata": {},
   "source": [
    "やや複雑ですが、また計算を追ってみましょう。まず角度$\\theta_1, \\theta_2, \\theta_3$は定義から以下の関係を満たします。\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "R_y(\\theta_1)\\ket{0} & = \\sqrt{\\frac{3}{10}} \\ket{0} + \\sqrt{\\frac{7}{10}} \\ket{1} \\\\\n",
    "R_y(\\theta_2)\\ket{0} & = \\sqrt{\\frac{1}{3}} \\ket{0} + \\sqrt{\\frac{2}{3}} \\ket{1} \\\\\n",
    "R_y(\\theta_3 - \\theta_2)R_y(\\theta_2)\\ket{0} & = R_y(\\theta_3)\\ket{0} = \\sqrt{\\frac{3}{7}} \\ket{0} + \\sqrt{\\frac{4}{7}} \\ket{1}.\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "したがって、\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "& C^1_0[R_y(\\theta_3 - \\theta_2)]R_{y1}(\\theta_1)R_{y0}(\\theta_2)\\ket{0}_1\\ket{0}_0 \\\\\n",
    "= & C^1_0[R_y(\\theta_3 - \\theta_2)]\\left(\\sqrt{\\frac{3}{10}} \\ket{0}_1 + \\sqrt{\\frac{7}{10}} \\ket{1}_1\\right) R_y(\\theta_2)\\ket{0}_0\\\\\n",
    "= & \\sqrt{\\frac{3}{10}} \\ket{0}_1 R_y(\\theta_2)\\ket{0}_0 + \\sqrt{\\frac{7}{10}} \\ket{1}_1 R_y(\\theta_3)\\ket{0}_0 \\\\\n",
    "= & \\sqrt{\\frac{3}{10}} \\ket{0}_1 \\left(\\sqrt{\\frac{1}{3}} \\ket{0}_0 + \\sqrt{\\frac{2}{3}} \\ket{1}_0\\right) + \\sqrt{\\frac{7}{10}} \\ket{1}_1 \\left(\\sqrt{\\frac{3}{7}} \\ket{0}_0 + \\sqrt{\\frac{4}{7}} \\ket{1}_0\\right) \\\\\n",
    "= & \\sqrt{\\frac{1}{10}} \\ket{00} + \\sqrt{\\frac{2}{10}} \\ket{01} + \\sqrt{\\frac{3}{10}} \\ket{10} + \\sqrt{\\frac{4}{10}} \\ket{11}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "最初の行で、ビット0と1にかかる$R_y$ゲートをそれぞれ$R_{y0}, R_{y1}$と表しました。\n",
    "\n",
    "最後に$C[Z]$をかけると、$\\ket{11}$だけ符号が反転します。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "400f2a71",
   "metadata": {},
   "source": [
    "### 回路図の描き方と読み方\n",
    "\n",
    "量子回路を可視化する方法として、「回路図」の標準的な描き方が決まっています。Qiskitでは`QuantumCircuit`オブジェクトの`draw()`というメソッドを使って自動描画できます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de3fe32e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 663.998x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6537689",
   "metadata": {},
   "source": [
    "　ここで`draw()`の引数`'mpl'`はmatplotlibライブラリを使ってカラーで描くことを指定しています。実行環境によっては対応していないこともあるので、その場合は引数なしの`draw()`を使います。結果は`mpl`の場合に比べて見劣りしますが、内容は同じです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1d4babd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌────────────┐┌──────────────┐    ░ ┌─┐   \n",
       "   q_0: ┤ Ry(1.9106) ├┤ Ry(-0.19649) ├─■──░─┤M├───\n",
       "        ├────────────┤└──────┬───────┘ │  ░ └╥┘┌─┐\n",
       "   q_1: ┤ Ry(1.9823) ├───────■─────────■──░──╫─┤M├\n",
       "        └────────────┘                    ░  ║ └╥┘\n",
       "meas: 2/═════════════════════════════════════╩══╩═\n",
       "                                             0  1 </pre>"
      ],
      "text/plain": [
       "        ┌────────────┐┌──────────────┐    ░ ┌─┐   \n",
       "   q_0: ┤ Ry(1.9106) ├┤ Ry(-0.19649) ├─■──░─┤M├───\n",
       "        ├────────────┤└──────┬───────┘ │  ░ └╥┘┌─┐\n",
       "   q_1: ┤ Ry(1.9823) ├───────■─────────■──░──╫─┤M├\n",
       "        └────────────┘                    ░  ║ └╥┘\n",
       "meas: 2/═════════════════════════════════════╩══╩═\n",
       "                                             0  1 "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f606b461",
   "metadata": {},
   "source": [
    "回路図は左から右に読んでいきます。水平の2本の実線が上からそれぞれ第0、第1量子ビットに対応し、その上にかぶさっている四角がゲート、最後にある矢印が下に伸びている箱が測定を表します。1ビットゲートから伸びている先端の丸い縦線は制御を表します。一番下の二重線は「古典レジスタ」（量子現象のない物理学を「古典物理学」と呼ぶので、量子でない通常のコンピュータにまつわる概念にはよく「古典 classical」という接頭辞をつけます）に対応し、測定結果の0/1が記録される部分です。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac07891",
   "metadata": {},
   "source": [
    "## CHSH不等式を計算する回路を書く\n",
    "\n",
    "それではいよいよ本題に入りましょう。CHSH不等式を「ベル状態」$1/\\sqrt{2}(\\ket{00} + \\ket{11})$で検証します。ベル状態は「どちらの量子ビットについても$\\ket{0}$でも$\\ket{1}$でもない状態」つまり、全体としては一つの定まった（純粋）状態であるにも関わらず、部分を見ると純粋でない状態です。このような時、**二つの量子ビットはエンタングルしている**といいます。エンタングルメントの存在は量子力学の非常に重要な特徴です。\n",
    "\n",
    "ベル状態はアダマールゲートとCNOTゲートを組み合わせて作ります。詳しい説明は{doc}`課題 <nonlocal_correlations>`に譲りますが、CHSH不等式の検証用の観測量を作るために、4つの回路I, II, III, IVを使います。回路IとIIIでは量子ビット1に対し測定の直前に$R_y(-\\pi/4)$、IIとIVでは同様に$R_y(-3\\pi/4)$を作用させます。また回路IIIとIVでは量子ビット0に$R_y(-\\pi/2)$を同じく測定の直前に作用させます。4つの回路を一度にIBMQに送るので、`circuits`というリストに回路を足していきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "05375b19",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "circuits = []\n",
    "\n",
    "# Circuit I - H, CX[0, 1], Ry(-π/4)[1]\n",
    "circuit = QuantumCircuit(2, name='circuit_I')\n",
    "circuit.h(0)\n",
    "circuit.cx(0, 1)\n",
    "circuit.ry(-np.pi / 4., 1)\n",
    "circuit.measure_all()\n",
    "# Append to list\n",
    "circuits.append(circuit)\n",
    "\n",
    "# Circuit II - H, CX[0, 1], Ry(-3π/4)[1]\n",
    "circuit = QuantumCircuit(2, name='circuit_II')\n",
    "circuit.h(0)\n",
    "circuit.cx(0, 1)\n",
    "circuit.ry(-3. * np.pi / 4., 1)\n",
    "circuit.measure_all()\n",
    "# Append to list\n",
    "circuits.append(circuit)\n",
    "\n",
    "# Circuit III - H, CX[0, 1], Ry(-π/4)[1], Ry(-π/2)[0]\n",
    "circuit = QuantumCircuit(2, name='circuit_III')\n",
    "circuit.h(0)\n",
    "circuit.cx(0, 1)\n",
    "circuit.ry(-np.pi / 4., 1)\n",
    "circuit.ry(-np.pi / 2., 0)\n",
    "circuit.measure_all()\n",
    "# Append to list\n",
    "circuits.append(circuit)\n",
    "\n",
    "# Circuit IV - H, CX[0, 1], Ry(-3π/4)[1], Ry(-π/2)[0]\n",
    "circuit = QuantumCircuit(2, name='circuit_IV')\n",
    "circuit.h(0)\n",
    "circuit.cx(0, 1)\n",
    "circuit.ry(-3. * np.pi / 4., 1)\n",
    "circuit.ry(-np.pi / 2., 0)\n",
    "circuit.measure_all()\n",
    "# Append to list\n",
    "circuits.append(circuit)\n",
    "\n",
    "# draw() can accept a matplotlib Axes object as an argument, to which the circuit will be drawn\n",
    "# This is useful when visualizing multiple circuits from a single Jupyter cell\n",
    "fig, axs = plt.subplots(2, 2, figsize=[12., 6.])\n",
    "for circuit, ax in zip(circuits, axs.reshape(-1)):\n",
    "    circuit.draw('mpl', ax=ax)\n",
    "    ax.set_title(circuit.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "714bc12c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "それぞれの回路で2ビットレジスタの基底$\\ket{00}, \\ket{01}, \\ket{10}, \\ket{11}$が現れる確率を計算してみましょう。\n",
    "\n",
    "回路Iの状態は\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "R_{y1}\\left(-\\frac{\\pi}{4}\\right) C^0_1[X] H_0 \\ket{0}_1\\ket{0}_0 = & R_{y1}\\left(-\\frac{\\pi}{4}\\right) \\frac{1}{\\sqrt{2}} (\\ket{0}_1\\ket{0}_0 + \\ket{1}_1\\ket{1}_0) \\\\\n",
    "= & \\frac{1}{\\sqrt{2}} \\big[(c\\ket{0}_1 - s\\ket{1}_1)\\ket{0}_0 + (s\\ket{0}_1 + c\\ket{1}_1)\\ket{1}_0\\big]\\\\\n",
    "= & \\frac{1}{\\sqrt{2}} (c\\ket{00} + s\\ket{01} - s\\ket{10} + c\\ket{11}).\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "簡単のため$c = \\cos(\\pi/8), s = \\sin(\\pi/8)$とおきました。\n",
    "\n",
    "したがって回路Iでの確率$P^{\\rmI}_{l} \\, (l=00,01,10,11)$は\n",
    "\n",
    "$$\n",
    "P^{\\rmI}_{00} = P^{\\rmI}_{11} = \\frac{c^2}{2} \\\\\n",
    "P^{\\rmI}_{01} = P^{\\rmI}_{10} = \\frac{s^2}{2}\n",
    "$$\n",
    "\n",
    "同様に、回路IIの状態は\n",
    "\n",
    "```{math}\n",
    ":label: eqn-circuit1\n",
    "R_{y1}\\left(-\\frac{3\\pi}{4}\\right) \\frac{1}{\\sqrt{2}} (\\ket{0}_1\\ket{0}_0 + \\ket{1}_1\\ket{1}_0) = \\frac{1}{\\sqrt{2}} (s\\ket{00} + c\\ket{01} - c\\ket{10} + s\\ket{11})\n",
    "```\n",
    "\n",
    "で確率$P^{\\rmII}_{l}$は\n",
    "\n",
    "$$\n",
    "P^{\\rmII}_{00} = P^{\\rmII}_{11} = \\frac{s^2}{2} \\\\\n",
    "P^{\\rmII}_{01} = P^{\\rmII}_{10} = \\frac{c^2}{2}\n",
    "$$\n",
    "\n",
    "です。回路IIIの状態は\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "& R_{y1}\\left(-\\frac{\\pi}{4}\\right) R_{y0}\\left(-\\frac{\\pi}{2}\\right) \\frac{1}{\\sqrt{2}} (\\ket{0}_1\\ket{0}_0 + \\ket{1}_1\\ket{1}_0) \\\\\n",
    "= & \\frac{1}{\\sqrt{2}} \\left[ \\frac{1}{\\sqrt{2}} (c\\ket{0}_1 - s\\ket{1}_1) (\\ket{0}_0 - \\ket{1}_0) + \\frac{1}{\\sqrt{2}} (s\\ket{0}_1 + c\\ket{1}_1) (\\ket{0}_0 + \\ket{1}_0) \\right] \\\\\n",
    "= & \\frac{1}{2} \\big[ (s+c)\\ket{00} + (s-c)\\ket{01} - (s-c)\\ket{10} + (s+c)\\ket{11} \\big]\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "で確率$P^{\\rmIII}_{l}$は\n",
    "\n",
    "$$\n",
    "P^{\\rmIII}_{00} = P^{\\rmIII}_{11} = \\frac{(s + c)^2}{4} \\\\\n",
    "P^{\\rmIII}_{01} = P^{\\rmIII}_{10} = \\frac{(s - c)^2}{4}\n",
    "$$\n",
    "\n",
    "同様に回路IVの状態と確率$P^{\\rmIV}_l$は\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "& R_{y1}\\left(-\\frac{3\\pi}{4}\\right) R_{y0}\\left(-\\frac{\\pi}{2}\\right) \\frac{1}{\\sqrt{2}} (\\ket{0}_1\\ket{0}_0 + \\ket{1}_1\\ket{1}_0) \\\\\n",
    "= & \\frac{1}{2} \\big[ (s+c)\\ket{00} - (s-c)\\ket{01} + (s-c)\\ket{10} + (s+c)\\ket{11} \\big]\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "$$\n",
    "P^{\\rmIV}_{00} = P^{\\rmIV}_{11} = \\frac{(s + c)^2}{4} \\\\\n",
    "P^{\\rmIV}_{01} = P^{\\rmIV}_{10} = \\frac{(s - c)^2}{4}\n",
    "$$\n",
    "\n",
    "となります。\n",
    "\n",
    "それぞれの回路でビット0と1で同じ値が観測される確率$P^{i}_{00} + P^{i}_{11}$から異なる値が観測される確率$P^{i}_{01} + P^{i}_{10}$を引いた値を$C^{i}$と定義します。\n",
    "\n",
    "$$\n",
    "C^{\\rmI} = c^2 - s^2 = \\cos\\left(\\frac{\\pi}{4}\\right) = \\frac{1}{\\sqrt{2}} \\\\\n",
    "C^{\\rmII} = s^2 - c^2 = -\\frac{1}{\\sqrt{2}} \\\\\n",
    "C^{\\rmIII} = 2sc = \\sin\\left(\\frac{\\pi}{4}\\right) = \\frac{1}{\\sqrt{2}} \\\\\n",
    "C^{\\rmIV} = 2sc = \\frac{1}{\\sqrt{2}}\n",
    "$$\n",
    "\n",
    "なので、これらの組み合わせ$S = C^{\\rmI} - C^{\\rmII} + C^{\\rmIII} + C^{\\rmIV}$の値は$2\\sqrt{2}$です。\n",
    "\n",
    "実は、エンタングルメントが起こらない場合、この観測量$S$の値は2を超えられないことが知られています。例えば$R_y$ゲートをかける前の状態がベル状態ではなく、確率$\\frac{1}{2}$で$\\ket{00}$、確率$\\frac{1}{2}$で$\\ket{11}$という「混合状態」である場合、\n",
    "\n",
    "$$\n",
    "C^{\\rmI} = \\frac{1}{\\sqrt{2}} \\\\\n",
    "C^{\\rmII} = -\\frac{1}{\\sqrt{2}} \\\\\n",
    "C^{\\rmIII} = 0 \\\\\n",
    "C^{\\rmIV} = 0\n",
    "$$\n",
    "\n",
    "となり、$S = \\sqrt{2} < 2$です。これがCHSH不等式です。\n",
    "\n",
    "それでは、IBMQの「量子コンピュータ」が実際にエンタングル状態を生成できるのか、上の四つの回路から$S$の値を計算して確認してみましょう。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9309a2a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "## 回路を実機で実行する\n",
    "\n",
    "まずはIBM Quantumに認証・接続します。IBM Quantum Lab (IBM Quantumウェブサイト上のJupyter Lab)で実行している、もしくは自分のラップトップなどローカルの環境ですでに{ref}`認証設定が保存されている <install_token>`場合は\n",
    "```{code-block} python\n",
    "service = QiskitRuntimeService(channel='ibm_quantum')\n",
    "```\n",
    "で接続ができます。設定がない場合は`QiskitRuntimeService`のコンストラクタに{ref}`トークン <install_token>`を渡してIBM Quantumに接続します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4bff3688",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "remove-output",
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "IBMNotAuthorizedError",
     "evalue": "'401 Client Error: Unauthorized for url: https://auth.quantum-computing.ibm.com/api/users/loginWithToken. Login failed., Error code: 3446.'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAccountNotFoundError\u001b[0m                      Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[7], line 6\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m----> 6\u001b[0m     service \u001b[38;5;241m=\u001b[39m \u001b[43mQiskitRuntimeService\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchannel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mibm_quantum\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minstance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m AccountNotFoundError:\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:124\u001b[0m, in \u001b[0;36mQiskitRuntimeService.__init__\u001b[0;34m(self, channel, token, url, filename, name, instance, proxies, verify, channel_strategy)\u001b[0m\n\u001b[1;32m    122\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m()\n\u001b[0;32m--> 124\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_account \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_discover_account\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    125\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtoken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtoken\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    126\u001b[0m \u001b[43m    \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    127\u001b[0m \u001b[43m    \u001b[49m\u001b[43minstance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    128\u001b[0m \u001b[43m    \u001b[49m\u001b[43mchannel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchannel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    129\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    130\u001b[0m \u001b[43m    \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    131\u001b[0m \u001b[43m    \u001b[49m\u001b[43mproxies\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mProxyConfiguration\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproxies\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mproxies\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    132\u001b[0m \u001b[43m    \u001b[49m\u001b[43mverify\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverify\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    133\u001b[0m \u001b[43m    \u001b[49m\u001b[43mchannel_strategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchannel_strategy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    134\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    136\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_client_params \u001b[38;5;241m=\u001b[39m ClientParameters(\n\u001b[1;32m    137\u001b[0m     channel\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_account\u001b[38;5;241m.\u001b[39mchannel,\n\u001b[1;32m    138\u001b[0m     token\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_account\u001b[38;5;241m.\u001b[39mtoken,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    142\u001b[0m     verify\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_account\u001b[38;5;241m.\u001b[39mverify,\n\u001b[1;32m    143\u001b[0m )\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:239\u001b[0m, in \u001b[0;36mQiskitRuntimeService._discover_account\u001b[0;34m(self, token, url, instance, channel, filename, name, proxies, verify, channel_strategy)\u001b[0m\n\u001b[1;32m    238\u001b[0m             logger\u001b[38;5;241m.\u001b[39mwarning(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLoading default \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m account. Input \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124murl\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m is ignored.\u001b[39m\u001b[38;5;124m\"\u001b[39m, channel)\n\u001b[0;32m--> 239\u001b[0m         account \u001b[38;5;241m=\u001b[39m \u001b[43mAccountManager\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchannel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchannel\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    240\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28many\u001b[39m([token, url]):\n\u001b[1;32m    241\u001b[0m     \u001b[38;5;66;03m# Let's not infer based on these attributes as they may change in the future.\u001b[39;00m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/accounts/management.py:195\u001b[0m, in \u001b[0;36mAccountManager.get\u001b[0;34m(cls, filename, name, channel)\u001b[0m\n\u001b[1;32m    193\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m Account\u001b[38;5;241m.\u001b[39mfrom_saved_format(all_config[account_name])\n\u001b[0;32m--> 195\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m AccountNotFoundError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnable to find account.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAccountNotFoundError\u001b[0m: 'Unable to find account.'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mHTTPError\u001b[0m                                 Traceback (most recent call last)",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/session.py:329\u001b[0m, in \u001b[0;36mRetrySession.request\u001b[0;34m(self, method, url, bare, **kwargs)\u001b[0m\n\u001b[1;32m    328\u001b[0m     response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mrequest(method, final_url, headers\u001b[38;5;241m=\u001b[39mheaders, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 329\u001b[0m     \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    330\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m RequestException \u001b[38;5;28;01mas\u001b[39;00m ex:\n\u001b[1;32m    331\u001b[0m     \u001b[38;5;66;03m# Wrap the requests exceptions into a IBM Q custom one, for\u001b[39;00m\n\u001b[1;32m    332\u001b[0m     \u001b[38;5;66;03m# compatibility.\u001b[39;00m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/requests/models.py:1021\u001b[0m, in \u001b[0;36mResponse.raise_for_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1020\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m http_error_msg:\n\u001b[0;32m-> 1021\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m HTTPError(http_error_msg, response\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m)\n",
      "\u001b[0;31mHTTPError\u001b[0m: 401 Client Error: Unauthorized for url: https://auth.quantum-computing.ibm.com/api/users/loginWithToken",
      "\nThe above exception was the direct cause of the following exception:\n",
      "\u001b[0;31mIBMNotAuthorizedError\u001b[0m                     Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[7], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m     service \u001b[38;5;241m=\u001b[39m QiskitRuntimeService(channel\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mibm_quantum\u001b[39m\u001b[38;5;124m'\u001b[39m, instance\u001b[38;5;241m=\u001b[39minstance)\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m AccountNotFoundError:\n\u001b[0;32m----> 8\u001b[0m     service \u001b[38;5;241m=\u001b[39m \u001b[43mQiskitRuntimeService\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchannel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mibm_quantum\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m__paste_your_token_here__\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minstance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:158\u001b[0m, in \u001b[0;36mQiskitRuntimeService.__init__\u001b[0;34m(self, channel, token, url, filename, name, instance, proxies, verify, channel_strategy)\u001b[0m\n\u001b[1;32m    156\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[1;32m    157\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 158\u001b[0m     auth_client \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_authenticate_ibm_quantum_account\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_client_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    159\u001b[0m     \u001b[38;5;66;03m# Update client parameters to use authenticated values.\u001b[39;00m\n\u001b[1;32m    160\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_client_params\u001b[38;5;241m.\u001b[39murl \u001b[38;5;241m=\u001b[39m auth_client\u001b[38;5;241m.\u001b[39mcurrent_service_urls()[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mservices\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mruntime\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:334\u001b[0m, in \u001b[0;36mQiskitRuntimeService._authenticate_ibm_quantum_account\u001b[0;34m(self, client_params)\u001b[0m\n\u001b[1;32m    327\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m version_info[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnew_api\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mapi-auth\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m version_info:\n\u001b[1;32m    328\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m IBMInputValueError(\n\u001b[1;32m    329\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe URL specified (\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m) is not an IBM Quantum authentication URL. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    330\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mValid authentication URL: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\n\u001b[1;32m    331\u001b[0m             client_params\u001b[38;5;241m.\u001b[39murl, QISKIT_IBM_RUNTIME_API_URL\n\u001b[1;32m    332\u001b[0m         )\n\u001b[1;32m    333\u001b[0m     )\n\u001b[0;32m--> 334\u001b[0m auth_client \u001b[38;5;241m=\u001b[39m \u001b[43mAuthClient\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclient_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    335\u001b[0m service_urls \u001b[38;5;241m=\u001b[39m auth_client\u001b[38;5;241m.\u001b[39mcurrent_service_urls()\n\u001b[1;32m    336\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m service_urls\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mservices\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\u001b[38;5;241m.\u001b[39mget(SERVICE_NAME):\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/clients/auth.py:39\u001b[0m, in \u001b[0;36mAuthClient.__init__\u001b[0;34m(self, client_params)\u001b[0m\n\u001b[1;32m     36\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_service_urls \u001b[38;5;241m=\u001b[39m {}  \u001b[38;5;66;03m# type: ignore[var-annotated]\u001b[39;00m\n\u001b[1;32m     38\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mauth_api \u001b[38;5;241m=\u001b[39m Api(RetrySession(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mauth_url, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mclient_params\u001b[38;5;241m.\u001b[39mconnection_parameters()))\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbase_api \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_init_service_clients\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mclient_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnection_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/clients/auth.py:51\u001b[0m, in \u001b[0;36mAuthClient._init_service_clients\u001b[0;34m(self, **request_kwargs)\u001b[0m\n\u001b[1;32m     42\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Initialize the clients used for communicating with the API.\u001b[39;00m\n\u001b[1;32m     43\u001b[0m \n\u001b[1;32m     44\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     48\u001b[0m \u001b[38;5;124;03m    Client for the API server.\u001b[39;00m\n\u001b[1;32m     49\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     50\u001b[0m \u001b[38;5;66;03m# Request an access token.\u001b[39;00m\n\u001b[0;32m---> 51\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maccess_token \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request_access_token\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mauth_api\u001b[38;5;241m.\u001b[39msession\u001b[38;5;241m.\u001b[39mauth \u001b[38;5;241m=\u001b[39m QuantumAuth(access_token\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maccess_token)\n\u001b[1;32m     53\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_service_urls \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muser_urls()\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/clients/auth.py:77\u001b[0m, in \u001b[0;36mAuthClient._request_access_token\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     67\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Request a new access token from the API authentication service.\u001b[39;00m\n\u001b[1;32m     68\u001b[0m \n\u001b[1;32m     69\u001b[0m \u001b[38;5;124;03mReturns:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     74\u001b[0m \u001b[38;5;124;03m    RequestsApiError: If the request failed.\u001b[39;00m\n\u001b[1;32m     75\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     76\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 77\u001b[0m     response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mauth_api\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlogin\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapi_token\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     78\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m response[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mid\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m     79\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m RequestsApiError \u001b[38;5;28;01mas\u001b[39;00m ex:\n\u001b[1;32m     80\u001b[0m     \u001b[38;5;66;03m# Get the original exception that raised.\u001b[39;00m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/rest/root.py:92\u001b[0m, in \u001b[0;36mApi.login\u001b[0;34m(self, api_token)\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Login with token.\u001b[39;00m\n\u001b[1;32m     84\u001b[0m \n\u001b[1;32m     85\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     89\u001b[0m \u001b[38;5;124;03m    JSON response.\u001b[39;00m\n\u001b[1;32m     90\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     91\u001b[0m url \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_url(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlogin\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 92\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpost\u001b[49m\u001b[43m(\u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjson\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mapiToken\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mapi_token\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mjson()\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/requests/sessions.py:637\u001b[0m, in \u001b[0;36mSession.post\u001b[0;34m(self, url, data, json, **kwargs)\u001b[0m\n\u001b[1;32m    626\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpost\u001b[39m(\u001b[38;5;28mself\u001b[39m, url, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, json\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    627\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Sends a POST request. Returns :class:`Response` object.\u001b[39;00m\n\u001b[1;32m    628\u001b[0m \n\u001b[1;32m    629\u001b[0m \u001b[38;5;124;03m    :param url: URL for the new :class:`Request` object.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    634\u001b[0m \u001b[38;5;124;03m    :rtype: requests.Response\u001b[39;00m\n\u001b[1;32m    635\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 637\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPOST\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mjson\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mjson\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/qiskit_ibm_runtime/api/session.py:350\u001b[0m, in \u001b[0;36mRetrySession.request\u001b[0;34m(self, method, url, bare, **kwargs)\u001b[0m\n\u001b[1;32m    348\u001b[0m             message \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mex\u001b[38;5;241m.\u001b[39mresponse\u001b[38;5;241m.\u001b[39mtext\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    349\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m status_code \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m401\u001b[39m:\n\u001b[0;32m--> 350\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m IBMNotAuthorizedError(message) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mex\u001b[39;00m\n\u001b[1;32m    351\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m RequestsApiError(message, status_code) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mex\u001b[39;00m\n\u001b[1;32m    353\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n",
      "\u001b[0;31mIBMNotAuthorizedError\u001b[0m: '401 Client Error: Unauthorized for url: https://auth.quantum-computing.ibm.com/api/users/loginWithToken. Login failed., Error code: 3446.'"
     ]
    }
   ],
   "source": [
    "# Specify an instance if you have access to multiple (e.g. premium access plan）\n",
    "# instance = 'hub-x/group-y/project-z'\n",
    "instance = None\n",
    "\n",
    "try:\n",
    "    service = QiskitRuntimeService(channel='ibm_quantum', instance=instance)\n",
    "except AccountNotFoundError:\n",
    "    service = QiskitRuntimeService(channel='ibm_quantum', token='__paste_your_token_here__', instance=instance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8285e1c",
   "metadata": {},
   "source": [
    "認証が済んだら、利用する量子コンピュータ（「バックエンド」と呼びます）を選びます。バックエンドで回路を実行するために、Samplerというインターフェースを使います。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "743d8fa0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception",
     "remove-output"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'service' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Find the backend that is operational and has the shortest job queue\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m backend \u001b[38;5;241m=\u001b[39m \u001b[43mservice\u001b[49m\u001b[38;5;241m.\u001b[39mleast_busy(filters\u001b[38;5;241m=\u001b[39moperational_backend())\n\u001b[1;32m      3\u001b[0m sampler \u001b[38;5;241m=\u001b[39m Sampler(backend)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mJobs will run on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbackend\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'service' is not defined"
     ]
    }
   ],
   "source": [
    "# Find the backend that is operational and has the shortest job queue\n",
    "backend = service.least_busy(filters=operational_backend())\n",
    "sampler = Sampler(backend)\n",
    "\n",
    "print(f'Jobs will run on {backend.name}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad9e009c",
   "metadata": {},
   "source": [
    "回路をバックエンドに送るには、`transpile`という関数とSamplerの`run`というメソッドを使います。`transpile`については次回{ref}`transpilation`で説明するので、今は「おまじない」だと思ってください。`run`で回路を送るとき、前述したように同時にショット数を指定します。バックエンドごとに一度のジョブでの最大ショット数が決められており、8192、30000、100000などとさまざまです。回路をバックエンドに渡し、`shots`回実行させることをジョブと呼びます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1448250e",
   "metadata": {
    "tags": [
     "raises-exception",
     "remove-output"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'backend' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[9], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# max_shots = the maximum number of allowed shots for this backend with the access parameters\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m shots \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmin\u001b[39m(\u001b[43mbackend\u001b[49m\u001b[38;5;241m.\u001b[39mmax_shots, \u001b[38;5;241m2000\u001b[39m)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRunning four circuits, \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mshots\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m shots each\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      5\u001b[0m circuits \u001b[38;5;241m=\u001b[39m transpile(circuits, backend\u001b[38;5;241m=\u001b[39mbackend)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'backend' is not defined"
     ]
    }
   ],
   "source": [
    "# max_shots = the maximum number of allowed shots for this backend with the access parameters\n",
    "shots = min(backend.max_shots, 2000)\n",
    "print(f'Running four circuits, {shots} shots each')\n",
    "\n",
    "circuits = transpile(circuits, backend=backend)\n",
    "# Execute each circuit for `shots` times\n",
    "job = sampler.run(circuits, shots=shots)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d1366e5",
   "metadata": {},
   "source": [
    "これで回路がバックエンドに送られ、キューに入りました。ジョブの実行結果は`run`メソッドの返り値であるジョブオブジェクトから参照します。\n",
    "\n",
    "IBMQのバックエンドは世界中からたくさんのユーザーに利用されているため、場合によっては予約されているジョブが多数あってキューにかなりの待ち時間が生じることがあります。\n",
    "\n",
    "バックエンドごとのキューの長さは<a href=\"https://quantum.ibm.com/services/resources\" target=\"_blank\">IBM Quantumのバックエンド一覧ページ</a>から確認できます。バックエンドを一つクリックすると詳細が表示され、現在の全ジョブ数が Total pending jobs として表示されます。また、一番下の Your access providers という欄でバックエンドのジョブあたりの最大ショット数と最大回路数を確認できます。\n",
    "\n",
    "また、自分の投じたジョブのステータスは<a href=\"https://quantum.ibm.com/jobs\" target=\"_blank\">ジョブ一覧ページ</a>から確認できます。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c14e5900",
   "metadata": {},
   "source": [
    "## 量子測定結果の解析\n",
    "\n",
    "ジョブオブジェクトの`result()`というメソッドを呼ぶと、ジョブが完了して結果が帰ってくるまでコードの実行が止まります。実行結果はオブジェクトとして返され、Samplerに渡した各回路毎にインデックスされています。回路毎のデータの`get_counts`というメソッドを使うと、各ビット列が何回観測されたかというヒストグラムデータがPythonのdictとして得られます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0934eab",
   "metadata": {
    "tags": [
     "raises-exception",
     "remove-output"
    ]
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'job' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mjob\u001b[49m\u001b[38;5;241m.\u001b[39mresult()\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m# List to collect the histogram data from the four circuits\u001b[39;00m\n\u001b[1;32m      4\u001b[0m counts_list \u001b[38;5;241m=\u001b[39m []\n",
      "\u001b[0;31mNameError\u001b[0m: name 'job' is not defined"
     ]
    }
   ],
   "source": [
    "result = job.result()\n",
    "\n",
    "# List to collect the histogram data from the four circuits\n",
    "counts_list = []\n",
    "\n",
    "# Extracting the bit sequence counts from the result object\n",
    "for idx in range(4):\n",
    "    # get_counts(i) returns the histogram data for circuit i\n",
    "    counts = result[idx].data.meas.get_counts()\n",
    "    # Append to list\n",
    "    counts_list.append(counts)\n",
    "\n",
    "print(counts_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "208d989e",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "# テキスト作成用のダミーセルなので無視してよい\n",
    "try:\n",
    "    counts_list\n",
    "except NameError:\n",
    "    counts_list = [\n",
    "        {'00': 3339, '01': 720, '10': 863, '11': 3270},\n",
    "        {'00': 964, '01': 3332, '10': 3284, '11': 612},\n",
    "        {'00': 3414, '01': 693, '10': 953, '11': 3132},\n",
    "        {'00': 3661, '01': 725, '10': 768, '11': 3038}\n",
    "    ]\n",
    "\n",
    "    shots = 8192"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbbbf2e",
   "metadata": {},
   "source": [
    "````{tip}\n",
    "ノートブックの接続が切れてしまったり、過去に走らせたジョブの結果を再び解析したくなったりした場合は、ジョブIDを使って`retrieve_job`というメソッドでジョブオブジェクトを再構成することができます。過去に走らせたジョブはIBM Quantumのホームページにリストされているので、そこにあるジョブID（cgr3kaemln50ss91pj10のような）をコピーし、\n",
    "\n",
    "```{code-block} python\n",
    "backend = provider.get_backend('__backend_you_used__')\n",
    "job = backend.retrieve_job('__job_id__')\n",
    "```\n",
    "\n",
    "とすると、`backend.run`によって返されたのと同じようにジョブオブジェクトが生成されます。\n",
    "````\n",
    "\n",
    "Qiskitから提供されている`plot_histogram`関数を使って、この情報を可視化できます。プロットの縦軸は観測回数を全測定数で割って、観測確率に規格化してあります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c3df7207",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(2, 2, sharey=True, figsize=[12., 8.])\n",
    "for counts, circuit, ax in zip(counts_list, circuits, axs.reshape(-1)):\n",
    "    plot_histogram(counts, ax=ax)\n",
    "    ax.set_title(circuit.name)\n",
    "    ax.yaxis.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "675dd0e9",
   "metadata": {},
   "source": [
    "$c^2/2 = (s + c)^2/4 = 0.427$, $s^2/2 = (s - c)^2 / 4 = 0.073$なので、得られた確率は当たらずとも遠からずというところでしょうか。\n",
    "\n",
    "実は現在の量子コンピュータにはまだ様々なノイズやエラーがあり、計算結果は往々にして理論的な値から統計誤差の範囲を超えてずれます。特定のエラーに関しては多少の緩和法も存在しますが、全て防げるわけでは決してありません。現在の量子コンピュータを指して \"*Noisy* intermediate-scale quantum (NISQ) device\" と呼んだりしますが、このNoisyの部分はこのような簡単な実験でもすでに顕著に現れるわけです。\n",
    "\n",
    "逆に、NISQデバイスを有効活用するには、ノイズやエラーがあっても意味のある結果が得られるようなロバストな回路が求められます。{doc}`vqe`で紹介する変分量子回路を用いた最適化などがその候補として注目されています。\n",
    "\n",
    "さて、それでは最後にCHSH不等式の破れを確認してみましょう。$C^{\\rmI}, C^{\\rmII}, C^{\\rmIII}, C^{\\rmIV}$を計算して$S$を求めます。\n",
    "\n",
    "下のコードで`counts`という辞書オブジェクトからキー`'00'`などに対応する値を取り出す際に`counts['00']`ではなく`counts.get('00', 0)`としています。二つの表現は`counts`に`'00'`というキーが定義されていれば全く同義ですが、キーが定義されていないときは、前者の場合エラーとして実行が止まるのに対して、後者ではデフォルト値として2個目の引数で指定されている`0`が返ってきます。qiskitの結果データは一度も測定されなかったビット列についてキーを持たないので、常に`get`でカウント数を抽出するようにしましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ce589e94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C: [ 0.61352539 -0.61523438  0.59814453  0.63549805]\n",
      "S = 2.46240234375\n",
      "Yes, we are using a quantum computer!\n"
     ]
    }
   ],
   "source": [
    "# C^I, C^II, C^III, C^IVを一つのアレイにする\n",
    "#（今の場合ただのリストにしてもいいが、純粋な数字の羅列にはnumpy arrayを使うといいことが多い）\n",
    "c_arr = np.zeros(4, dtype=float)\n",
    "\n",
    "# enumerate(L)でリストのインデックスと対応する要素に関するループを回せる\n",
    "for ic, counts in enumerate(counts_list):\n",
    "    # counts['00'] でなく counts.get('00', 0) - 上のテキストを参照\n",
    "    c_arr[ic] = counts.get('00', 0) + counts.get('11', 0) - counts.get('01', 0) - counts.get('10', 0)\n",
    "\n",
    "# 4つの要素を同時にshotsで規格化（リストではこういうことはできない）\n",
    "c_arr /= shots\n",
    "\n",
    "s_val = c_arr[0] - c_arr[1] + c_arr[2] + c_arr[3]\n",
    "\n",
    "print('C:', c_arr)\n",
    "print('S =', s_val)\n",
    "if s_val > 2.:\n",
    "    print('Yes, we are using a quantum computer!')\n",
    "else:\n",
    "    print('Armonk, we have a problem.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4e75b19",
   "metadata": {},
   "source": [
    "無事、$S$が2を超えました。"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "notebook_metadata_filter": "all",
   "text_representation": {
    "extension": ".md",
    "format_name": "myst",
    "format_version": 0.13,
    "jupytext_version": "1.16.1"
   }
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  },
  "source_map": [
   23,
   27,
   43,
   51,
   59,
   75,
   152,
   183,
   193,
   248,
   265,
   274,
   332,
   345,
   373,
   379,
   381,
   385,
   387,
   391,
   399,
   453,
   547,
   557,
   572,
   576,
   588,
   592,
   602,
   612,
   618,
   636,
   651,
   666,
   672,
   684,
   705
  ]
 },
 "nbformat": 4,
 "nbformat_minor": 5
}