{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"教室でQiskitを始める\"\n",
"description: \"量子コンピューティングの基礎と、Qiskitを使って初めての量子回路を実行する方法について学びましょう。\"\n",
"---\n",
"\n",
"{/* cspell:ignore checkmark ccnot */}\n",
"\n",
"\n",
"\n",
"# 教室でQiskitを始める\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a84d2a96-7885-4f6c-b34a-f2d386d4e120",
"metadata": {},
"source": [
"このQiskit in Classroomsモジュールでは、以下のパッケージがインストールされた Python 環境が必要です：\n",
"\n",
"* `qiskit` v2.1.0 または新しい\n",
"* `qiskit-ibm-runtime` v0.40.1 または新しい\n",
"* `qiskit-aer` v0.17.0 または新しい\n",
"* `qiskit.visualization`\n",
"* `numpy`\n",
"* `pylatexenc`\n",
"\n",
"上記のパッケージをセットアップしてインストールするには、 [Qiskitのインストール](/docs/guides/install-qiskit)ガイドをご覧ください。\n",
"実際の量子コンピュータ上でジョブを実行するには、 [IBM Cloud® アカウントの設定](/docs/guides/cloud-setup)ガイドの手順に従って、 IBM Quantum® のアカウントを設定する必要があります。\n",
"\n",
"このモジュールはテストされ、Heron v2 プロセッサ上で2秒のQPU時間を使用した。 これはあくまでも目安である。 実際の使用方法は異なる場合があります。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d611274c-5988-45b7-98bf-01c57edc0b02",
"metadata": {},
"outputs": [],
"source": [
"# Uncomment and modify this line as needed to install dependencies\n",
"#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'"
]
},
{
"cell_type": "markdown",
"id": "9a7cc00a-e11d-46e7-9737-1ec7a3fa9951",
"metadata": {},
"source": [
"\n",
"\n",
"## 概要\n",
"\n",
"Qiskit in the Classroomモジュールでは、量子コンピュータを使って、量子力学、コンピュータサイエンス、化学など、量子コンピュータに隣接する分野のさまざまな概念を探求する機会があります。 このモジュールは、量子コンピューティングの基礎と、量子回路を実行するためのQiskitの使い方を紹介します。\n",
"\n",
"まず古典的なコンピュータの仕組みを簡単に説明し、次にこれらの概念を量子コンピュータのパラダイムにどのように適合させるかを紹介する。 最後に、これらのコンセプトを組み合わせて最初の量子回路を作り、実行する方法を紹介する。\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "742678ad-9e14-4691-bc6f-5900c7f45f9b",
"metadata": {},
"source": [
"\n",
"\n",
"## 古典的コンピュータ\n",
"\n",
"古典的なコンピュータの基本的な仕組みはよくご存知だと思うが、ここでは量子コンピュータとの比較をするために、主要な特徴をいくつか紹介しよう。\n",
"\n",
"\n",
"\n",
"### 情報の基本単位：ビット\n",
"\n",
"古典コンピュータは古典情報を処理し、古典情報の基本単位は*ビット*である。 1ビットに1つの「はい／いいえ」の質問の答えを格納することができる。 私たちは通常、ビットの2進状態を \"0 \"と \"1 \"で表す。\n",
"\n",
"\n",
"\n",
"#### 2進数の復習\n",
"\n",
"ビットを組み合わせることで、より多くの情報を保存することができる。 例えば、0から15までの数字を格納したい場合、次のように4ビットで格納することができる：\n",
"\n",
"| | | | |\n",
"| :------- | :------: | :-------: | --------: |\n",
"| 0 = 0000 | 4 = 0100 | 8 = 1000 | 12 = 1100 |\n",
"| 1 = 0001 | 5 = 0101 | 9 = 1001 | 13 = 1101 |\n",
"| 2 = 0010 | 6 = 0110 | 10 = 1010 | 14 = 1110 |\n",
"| 3 = 0011 | 7 = 0111 | 11 = 1011 | 15 = 1111 |\n",
"\n",
"一般に、 $N$ ビットの2進数から、おなじみの base-10 数に変換するには、最下位（右端）のビットに $2^0 = 1$ を掛け、その次のビットに $2^1 = 2$ を掛け、その次のビットに $2^2 = 4$ を掛け、というように、最上位（左端）のビットに達するまで、 $2^{N-1}$ を掛けます。\n",
"\n",
"つまり、 $N$ ビットは、 $2^N$ のいずれかの状態になりうるということだ。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"86という数字を表すには何ビットが必要ですか？ この数値を2進数でエンコードしたビット列を書き出す。\n",
"\n",
"\n",
" \n",
" 覚えておいてほしいのは、 $N$ ビットで、 $0$ から $2^N - 1$ までの数字を表現できるので、6ビットを使えば $2^6 - 1 = 63$ まで表現できる。 もう1ビット追加して、 $2^7 - 1 = 127$。 では、86を2の累乗に分解してみよう：\n",
"\n",
" $$\n",
" \\begin{aligned}\n",
" 86 &= 64 + 16 + 4 + 2 \\\\\n",
" &= 2^6 \\times 1 + 2^5 \\times 0 + 2^4 \\times 1 + 2^3 \\times 0 + 2^2 \\times 1 + 2^1 \\times 1 + 2^0 \\times 0 \\\\\n",
" &= 1010110\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"### 基本演算：論理ゲート\n",
"\n",
"さて、コンピュータが計算するためには、ビットを使って何かを*する*必要がある。 バイナリゲートは、より複雑なアルゴリズムやコードの基本的な構成要素を形成する演算である。\n",
"\n",
"\n",
"\n",
"### シングルビットゲート：\n",
"\n",
"\n",
"\n",
"#### NOT\n",
"\n",
"ビットが1つしかない場合、そのビットの状態を変換する方法は1つしかない。 私たちはこれを \"NOT \"ゲートと呼んでいる。 このゲートの効果は、以下で説明する他のゲートも含めて、いわゆる「真理値表」で表すことができ、列は量子ビットの入力と出力の状態を表す。 NOTゲートの真理値表はこうなる：\n",
"\n",
"| 入力 | 出力 |\n",
"| :- | -: |\n",
"| 0 | 1 |\n",
"| 1 | 0 |\n",
"\n",
"\n",
"\n",
"### マルチビットゲート：\n",
"\n",
"\n",
"\n",
"#### および\n",
"\n",
"ANDは、2つの入力ビットを受け取り、1つのビットを出力する2ビットゲートである。 入力ビットが両方とも1であれば1を出力し、そうでなければ0を出力する：\n",
"\n",
"| 入力 | 出力 |\n",
"| :- | -: |\n",
"| 00 | 0 |\n",
"| 1 | 0 |\n",
"| 10 | 0 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### または\n",
"\n",
"ORも出力ビットが1つの2ビットゲートである。 *いずれかの*ビットが1の場合、1を出力する：\n",
"\n",
"| 入力 | 出力 |\n",
"| :- | -: |\n",
"| 00 | 0 |\n",
"| 1 | 1 |\n",
"| 10 | 1 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### XOR\n",
"\n",
"XORは「排他的論理和」の略で、ORゲートのようなものだが、入力ビットのうち *1つだけが* 1の場合に1を出力する。 両方1か両方0の場合は0を出力する：\n",
"\n",
"| 入力 | 出力 |\n",
"| :- | -: |\n",
"| 00 | 0 |\n",
"| 1 | 1 |\n",
"| 10 | 1 |\n",
"| 11 | 0 |\n",
"\n",
"\n",
"\n",
"### 寸法:\n",
"\n",
"通常、古典的なコンピューティングを学ぶ場合、ビットの状態を読み出すプロセスにはあまり注意が払われない。 概念的にはそれほど複雑ではないからだ。 計算の前でも途中でも後でも、いつでもビットを測定することができ、結果に影響を与えることはない。 後述するように、量子コンピューティングの場合はそうではない。\n",
"\n",
"\n",
"\n",
"### 回路：\n",
"\n",
"上記のゲートを組み合わせることで、コンピューター上であらゆる操作を行うことができる。 簡単な例を見てみよう：ANDゲートとXORゲートを使って、2ビットの和を計算する半加算回路を作ることができる。 これは論理回路図で表され、ワイヤーはビットを表し、ビット上で動作するゲートは対応するワイヤー上のシンボルで示される：\n",
"\n",
"\n",
"\n",
"そこで、2つのビットをコピーし、ANDゲートとXORゲートの両方に通す。 XORゲートの結果は「サム・ビット」（S）であり、2進数の1位のままであり、ANDゲートの結果は「キャリー・ビット」（C）であり、2進数の最上位桁の次の桁の値である。 これが真理値表だ：\n",
"\n",
"| $A$ | $B$ | 和 ( $A \\oplus B$ ) | キャリー ( $A \\wedge B$ ) |\n",
"| --- | --- | ------------------ | --------------------- |\n",
"| 0 | 0 | 0 | 0 |\n",
"| 0 | 1 | 1 | 0 |\n",
"| 1 | 0 | 1 | 0 |\n",
"| 1 | 1 | 0 | 1 |\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"上の真理値表が加算回路の正しい解を導くことを確認しなさい。 すなわち、AとBの4つの選択肢それぞれについて、 $A+B=S+2 \\times C$ を検証する。\n",
"\n",
"\n",
" \n",
" $$\n",
" \\begin{aligned}\n",
" 0+0 &= 0+0 = 0 ~\\checkmark \\\\\n",
" 0+1 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+0 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+1 &= 0+2 = 2 ~\\checkmark \\\\\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a324a959-5edc-4aaf-91ad-6bef9ab7c435",
"metadata": {},
"source": [
"\n",
"\n",
"## 量子コンピュータ\n",
"\n",
"\n",
"\n",
"### ビット $\\rightarrow$ 量子ビット\n",
"\n",
"ビットが古典的な情報の基本単位であるように、 *量子*ビット（量子ビット）は量子情報の基本単位である。 古典的なビットと同様に、量子ビットの状態は0か1のどちらかになります。通常、この状態を $\\vert 0\\rangle$ と $\\vert 1\\rangle$ と呼びます。しかし、古典ビットとは異なり、量子ビットは、 $\\vert 0\\rangle$ と $\\vert 1\\rangle$ の両方の状態を同時に*重ね合わせる*ことができる。 $\\vert \\psi\\rangle$ 一般的に、量子ビットはどのような状態にもなりうる：\n",
"\n",
"$$\n",
"\\vert \\psi\\rangle = c_0 \\vert 0\\rangle + c_1 \\vert 1\\rangle\n",
"$$\n",
"\n",
"ここで、 $c_0$ と $c_1$ は、 $\\vert c_0 \\vert ^2+\\vert c_1\\vert ^2=1$ を持つ複素振幅である。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "11563bfb-93d4-4a6a-9bd9-b52665ab4517",
"metadata": {},
"source": [
"\n",
"\n",
"#### 量子位相\n",
"\n",
"$c_0$ と $c_1$ は複素数なので、それぞれ $c_i = \\vert c_i\\vert e^{i\\phi_i}$ と書くことができ、 $\\phi_i$ は*位相と*呼ばれる。 状態全体に同じ全体的な位相係数をかけても、物理的には何も変わらない。これはグローバル位相と呼ばれ、観測可能な結果はない。\n",
"\n",
"そのため、 $e^{i\\phi_0}$、「因数分解」するのが通例となっている：\n",
"\n",
"$\\vert \\psi\\rangle = \\vert c_0\\vert \\vert 0\\rangle + \\vert c_1\\vert e^{i\\phi}\\vert 1\\rangle$\n",
"\n",
"ここで、 $\\phi = \\phi_1-\\phi_0$ は量子状態の*相対*位相であり\\*、\\* 観測可能な結果をもたらす。\n",
"\n",
"この段階は量子コンピューティングにおいて非常に重要な役割を果たしており、この後のQiskit in the Classroomモジュールでその様々な結果を探求することになる。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c35a8265-2d19-4743-99ac-39192e46f59a",
"metadata": {},
"source": [
"\n",
"\n",
"#### 複数の量子ビット\n",
"\n",
"複数のビットの状態は、単純に 0s と 1s の文字列として表現できるが、複数の量子ビットの状態は、 *重ね合わせと* *エンタングルメントの*原理により、少し複雑になる。\n",
"\n",
"$N$、2進数000...000から111...111までの $2^N$、いずれかの状態になる可能性があることを思い出してほしい。 しかし現在では、重ね合わせの原理により、 $N$ の*量子ビットは*、これら*すべての*状態を同時に重ね合わせることができる！\n",
"\n",
"これは次のように表すことができる\n",
"\n",
"$$\n",
"\\psi_N = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle\n",
"$$\n",
"\n",
"ここで、古典的な場合と同様に、 $\\vert i\\rangle$ の状態は、各qubitが 0s と 1s の正しい組み合わせにあり、2進数 $i$ が得られる状態に対応する。これらは量子系の「計算基底状態」として知られている。 例えば、3量子ビットの状態は、その8つの計算基底状態の重ね合わせとして書くことができる：\n",
"\n",
"$$\n",
"\\psi_3 = c_0 \\vert 000\\rangle + c_1 \\vert 001\\rangle + c_2 \\vert 010\\rangle + c_3 \\vert 011\\rangle + c_4 \\vert 100\\rangle + c_5 \\vert 101\\rangle + c_6 \\vert 110\\rangle + c_7 \\vert 111\\rangle\n",
"$$\n",
"\n",
"システム内の各qubitは $0$ から $N-1$ までのインデックスで示される。右から左へと量子ビットの状態を読むのが慣例で、 $0$ の状態が一番右の状態、 $N-1$ の状態が一番左の状態となる。 これは \"リトルエンディアン \"表記として知られており、私たちは左から右に読むことに慣れているので、最初は直感に反するように思えるかもしれない。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"一見、量子ビットをリトルエンディアン表記のように右から左に並べるのは直感に反するように思えるかもしれないが、実際には非常に論理的なことなのだ！ その理由を説明してください。 (2進数から base-10 数への変換に関する前述の議論を思い出してほしい)\n",
"\n",
"\n",
" \n",
" qubit0が最も右で、qubit N-1 が最も左になるように、qubitを右から左に並べると、qubit $0$ は最下位ビットと関連付けられ、 $2^0$ が乗算され、qubit $N-1$ は最上位ビットと関連付けられ、 $2^{N-1}$ が乗算される。\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### もつれ\n",
"\n",
"先に述べたように、量子ビットのもう一つの重要な特徴は、互いに*もつれ合う*ことができることである。 $c_0 = c_3 = \\frac{1}{\\sqrt{2}}$、 $c_1 = c_2 = 0$ ：\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 00\\rangle + \\vert 11\\rangle)$\n",
"\n",
"従って、量子ビット0の状態は、 $\\vert 0\\rangle$ または $\\vert 1\\rangle$ のいずれかに等しい確率でなり、量子ビット1の状態も同様である。 しかし、これらの確率はもはや互いに独立したものではない。 もし量子ビット0の状態が $\\vert 0\\rangle$ であることが分かれば、量子ビット1も $\\vert 0\\rangle$ になることが*分かる*。これが、もつれた状態を測定する行為が \"spooky action at a distance \"と呼ばれる理由である\n",
"\n",
"エンタングルメントには他の形もある。 例えば、州は\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 01\\rangle + \\vert 10\\rangle)$\n",
"\n",
"片方の量子ビットが $\\vert 0\\rangle$、もう片方は $\\vert 1\\rangle$。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"$\\vert \\psi\\rangle = \\vert 11\\rangle$ 状態はもつれているのか？ その理由は何か?\n",
"\n",
"\n",
" \n",
" 絡み合ってはいない。 両方の量子ビットを測定すると結果は常に同じになるが、これは各量子ビットが常に $\\vert 1\\rangle$ の状態に固定されているからに他ならない。一方の量子ビットを測定した結果は、実はもう一方の量子ビットに依存しない。両者は常に $\\vert 1\\rangle$。\n",
"\n",
" 一般的には、それぞれの量子ビットの状態を別々に記述し、それらをこのように掛け合わせることができる：\n",
"\n",
" $\\vert \\psi\\rangle = \\vert \\psi_1\\rangle \\vert \\psi_0\\rangle $\n",
"\n",
" その場合は「プロダクト状態」と呼ばれ、 *もつれない*。\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### ベクトル表記\n",
"\n",
"ベクトルや行列を使って、量子状態がさまざまな操作によってどのように変化するかを見ることは、しばしば役に立つ。 この表現では、量子状態はベクトルとなり、量子ゲート（次のセクションで説明する）はベクトルを変換する行列となる。\n",
"\n",
"単一量子ビットの場合、状態のベクトル形式は次のように選ばれる： $\\vert 0\\rangle = \\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$ $\\vert 1\\rangle = \\begin{pmatrix}0 \\\\ 1\\end{pmatrix}$ このようにして、任意の状態 $\\vert \\psi\\rangle = a\\vert 0\\rangle+b\\vert 1\\rangle$ は次のように書くことができる。 $\\vert \\psi\\rangle =\\begin{pmatrix}a \\\\ b\\end{pmatrix}$\n",
"\n",
"一般的な、 $n$ -qubitの状態については、 $2^n$ -次元ベクトルが必要である：\n",
"\n",
"$$\n",
"\\vert 0 \\dots 000\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ \\vdots \\\\ 0\\end{pmatrix}, \\vert 0 \\dots 001 \\rangle = \\vert 1 \\dots 110\\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 1 \\dots 111 \\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
"$$\n",
"\n",
"このベクトル表記法の選択を念頭に置いて、必要な量子ゲート、量子状態に対するその効果、およびその行列形式を紹介しよう。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"2量子ビット系には4つの計算基底状態がある。 それぞれをケット表記とベクトル表記の両方で書き出す。\n",
"\n",
"\n",
" \n",
" $$\n",
" \\vert 00\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ 0\\end{pmatrix}, \\vert 01 \\rangle = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0\\end{pmatrix}, \\dots, \\vert 10\\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 11 \\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "52f971a7-4a5e-4571-927b-23a642fae997",
"metadata": {},
"source": [
"\n",
"\n",
"## ゲート $\\rightarrow$ 量子ゲート\n",
"\n",
"NOT、AND、OR、XORといった古典ゲートを組み合わせて任意の古典回路を構築できるように、量子ゲートも量子コンピューティングで同じ役割を果たす。 量子ビットには量子力学的な特徴が追加されているため、量子ゲートはそれに応じて豊かになる。 真理値表を使って、 $|0\\rangle$ と $|1\\rangle$ の状態に基づいて彼らの行動を記述することはできるが、これは全体像を捉えるものではない。 量子ゲートは基底状態の重ね合わせに作用するため、行列表現を用いる方が自然な場合が多い。\n",
"\n",
"以下に、最も一般的な量子ゲートと、それらが相互作用する量子ビットをどのように変換するかを紹介する。 該当する場合は、お馴染みのクラシック・ゲートにつなげる。\n",
"\n",
"\n",
"\n",
"### 単一量子ビットゲート\n",
"\n",
"**$X$ ゲート** ：これはNOT演算に相当する量子演算である。 その真理値表は、古典的なNOTゲートにそっくりだ：\n",
"\n",
"| 入力 | 出力 |\n",
"| :--------------- | ---------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 1\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $\\vert 0\\rangle$ |\n",
"\n",
"そして行列表現：\n",
"\n",
"$X=\\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}$\n",
"\n",
"Qiskitでは、 $X$ ゲートで回路を作ると次のようになる：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "6c215e46-26cb-4e10-a1d7-2eecd2c18294",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.x(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "3a59abe3-5e75-4ff1-9f5e-9b24fd5c5ea0",
"metadata": {},
"source": [
"この非常に単純な回路図では、量子ビットは黒い水平線のワイヤーで表され、ゲートはそのワイヤー上のボックスとして表示されている。\n",
"\n",
"**ハダマードゲート：** 重ね合わせ状態を作り出す。 真理値表：\n",
"\n",
"| 入力 | 出力 |\n",
"| :--------------- | -------------------------------------------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle+\\vert 1\\rangle\\right)$ |\n",
"| $\\vert 1\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle-\\vert 1\\rangle\\right)$ |\n",
"\n",
"マトリックス表現： $H=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}$\n",
"\n",
"ハダマードゲートを使った回路は次のように作られる：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "1a009015-4ced-47e4-a18d-d0685e4cab47",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.h(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "9de7658f-e456-4788-81bb-6900c12ef054",
"metadata": {},
"source": [
"**$Z$ ゲート** ： $|1\\rangle$ の状態に $\\Delta \\phi = \\pi$ の位相シフトを加える：\n",
"\n",
"| 入力 | 出力 |\n",
"| :--------------- | ----------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $-\\vert 1\\rangle$ |\n",
"\n",
"$Z=\\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}$\n",
"\n",
"Qiskitでは、 $Z$ ゲートで回路を作ると次のようになる：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7bca3c98-884b-4709-bbe8-a9e16cc45698",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.z(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "c9ee10a5-5f69-4db4-87e9-bc1d3cd051eb",
"metadata": {},
"source": [
"**$T$ ゲート** ： $|1\\rangle$ の状態に $\\Delta \\phi = \\pi/4$ の位相シフトを加える：\n",
"\n",
"| 入力 | 出力 |\n",
"| :--------------- | -------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $e^{i\\pi/4}\\vert 1\\rangle$ |\n",
"\n",
"$T=\\begin{pmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{pmatrix}$\n",
"\n",
"Qiskitでは、 $T$ ゲートで回路を作ると次のようになる：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "ac699059-6be5-4a1a-89cb-97b7af412ab8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.t(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "52b43ac8-be21-4652-a139-7093fe27fd69",
"metadata": {},
"source": [
"\n",
"\n",
"### マルチ量子ビットゲート\n",
"\n",
"量子2ビットゲートは古典的な2ビットゲートに似ているが、1つ重要な注意点がある。 線形代数の用語では、これはユニタリー行列で表されることを意味する。 したがって、2つの入力量子ビットは常に2つの出力量子ビットに対応し、演算は原理的に元に戻すことができる。 これは、上で見たANDやORのような古典的ゲートとは対照的で、情報を失い、不可逆的である。\n",
"\n",
"**CNOT（Controlled-NOT）ゲート：** 2つの入力量子ビットは「コントロール」量子ビットと「ターゲット」量子ビットと呼ばれる。 制御量子ビットは変化しないが、その状態がターゲット量子ビットに何が起こるかを決定する。 制御量子ビットの状態が $\\vert 1\\rangle$ の場合、 $X$ ゲートがそのターゲットに適用される。制御量子ビットの状態が $\\vert 0\\rangle$ の場合、変更は行われない。 以下の表記では、 $A$ （一番右の量子ビット）がコントロールで、 $B$ （一番左の量子ビット）がターゲットであると仮定する。 以下では、次のように表記する。 $CNOT(q_{control},q_{target})\\vert BA\\rangle.$\n",
"\n",
"$CNOT(A,B)\\vert BA\\rangle_{input} = \\vert BA\\rangle_{output}$\n",
"\n",
"| 入力 | 出力 |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 11\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 01\\rangle$ |\n",
"\n",
"つまり、このアクションを表す行列は次のようになる：\n",
"\n",
"$CNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1c4dc48d-3d2b-4b4b-b405-c93504815ba9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.cx(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "be45af7b-a148-4b46-8379-3ac9658f50a9",
"metadata": {},
"source": [
"これは、2本のワイヤーで表される2つの量子ビットを持つ最初の回路図である。 CNOTゲートは2つの量子ビット間に実装され、 $q_0$ がコントロール、 $q_1$ がターゲットとなる。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"Qiskitでは、ほとんどのゲートが他の場所と同じマトリックス形式になっている。 しかし、CNOTゲートは2つの量子ビットに作用するので、突然、量子ビットの順序規則が問題になる。 量子ビットを $\\vert q_0,q_1,...\\rangle$、CNOTゲートに異なる行列形式を示す。 上記のCNOT行列が状態に対して正しい作用を持つことを、明示的な行列の乗算によって検証する。 $\\vert 01\\rangle.$\n",
"\n",
"\n",
" \n",
" $CNOT\\vert 01\\rangle =\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}\\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\0\\end{pmatrix} = \\begin{pmatrix}0 \\\\ 0 \\\\ 0 \\\\1\\end{pmatrix} = \\vert 11\\rangle$\n",
" \n",
"\n",
"\n",
"**SWAPゲート：** このゲートは2つの量子ビットの状態を入れ替える。 真理値表：\n",
"\n",
"| 入力 | 出力 |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 01\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 11\\rangle$ |\n",
"\n",
"つまり、このアクションを表す行列は次のようになる：\n",
"\n",
"$SWAP=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "118da691-4208-4248-a21f-a5e22815dc2c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "78199ae4-93e4-49a2-948a-f41a22187bae",
"metadata": {},
"source": [
"SWAPゲートは、実際には3つのCNOTから構成することができる。 その方法を見るには、Qiskitでゲートを `decompose()` ：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5efa09b9-b3e4-43fb-81f3-c33283a992d2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.decompose().draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "330362e5-f040-426f-a6d9-d730c917c7f2",
"metadata": {},
"source": [
"ここで初めて、回路図で複数のゲートがどのように示されているかがわかる。 左から右に読むので、一番左のゲートが最初に適用される。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"上記のCNOTの組み合わせがSWAPゲートになることを確認する。 行列の掛け算でも、他の方法でもできる。\n",
"\n",
"\n",
" \n",
" 行列の掛け算で：\n",
"\n",
" $\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix} = SWAP ~\\checkmark$\n",
"\n",
" 真理値表を使って、各CNOTによって状態がどのように変化するかを見る。 最後の列では、状態はSWAP真理値表の「出力」列と等価でなければならない：\n",
"\n",
" | 入力 | CNOT(A,B) | CNOT(B,A) | CNOT(A,B) |\n",
" | :---------------- | :---------------: | :---------------: | ---------------------------: |\n",
" | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle \\checkmark$ |\n",
" | $\\vert 01\\rangle$ | $\\vert 11\\rangle$ | $\\vert 10\\rangle$ | $\\vert 10\\rangle \\checkmark$ |\n",
" | $\\vert 10\\rangle$ | $\\vert 10\\rangle$ | $\\vert 11\\rangle$ | $\\vert 01\\rangle \\checkmark$ |\n",
" | $\\vert 11\\rangle$ | $\\vert 01\\rangle$ | $\\vert 01\\rangle$ | $\\vert 11\\rangle \\checkmark$ |\n",
" \n",
"\n",
"\n",
"**トフォリ・ゲート（または「制御-制御-NOT」（CCNOT））：** これは *3量子ビットの*ゲートです。 controlled-controlled-NOT \"という名前から、それがどのように機能するかはすでにお分かりかと思います。2つの制御量子ビットと1つのターゲット量子ビットがあり、 *両方の*制御量子ビットが $\\vert 1\\rangle$ の状態にある場合にのみ、ターゲット量子ビットの状態が反転します。我々はCNOTで使用した順序付けの規則を維持する：\n",
"\n",
"$$\n",
"CCNOT(Control A, Control B, Target C)\\vert CBA\\rangle\n",
"$$\n",
"\n",
"つまり、真理値表はこうなる：\n",
"\n",
"| 入力 | 出力 |\n",
"| :----------------- | -----------------: |\n",
"| $\\vert 000\\rangle$ | $\\vert 000\\rangle$ |\n",
"| $\\vert 001\\rangle$ | $\\vert 001\\rangle$ |\n",
"| $\\vert 010\\rangle$ | $\\vert 010\\rangle$ |\n",
"| $\\vert 011\\rangle$ | $\\vert 111\\rangle$ |\n",
"| $\\vert 100\\rangle$ | $\\vert 100\\rangle$ |\n",
"| $\\vert 101\\rangle$ | $\\vert 101\\rangle$ |\n",
"| $\\vert 110\\rangle$ | $\\vert 110\\rangle$ |\n",
"| $\\vert 111\\rangle$ | $\\vert 011\\rangle$ |\n",
"\n",
"そして、このアクションを表すマトリックスは\n",
"\n",
"$$\n",
"CCNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\end{pmatrix}\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "d1829257-b7a4-49d9-8ac2-3d6230165427",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(3)\n",
"qc.ccx(0, 1, 2)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "aa2e83e5-1197-473c-9f16-4c264b08aca0",
"metadata": {},
"source": [
"トフォリ・ゲートも、他のいくつかのゲートとともに、CNOTに分解することができる。 しかし、これはSWAPゲートの分解よりもかなり複雑であるため、この分解を探求し検証することは、モジュールの最後のオプション演習として残される。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "970302ee-eccc-48eb-b255-4a2d7bc8fbbc",
"metadata": {},
"source": [
"\n",
"\n",
"## 計測値\n",
"\n",
"測定は量子コンピュータにおいて特別な役割を果たす。 古典コンピューティングでは、アルゴリズム中の任意の時点でビットをチェックすることができるが、量子コンピューティングでは、量子ビットを見るタイミングを非常に選択しなければならない。なぜなら、測定によって量子ビットの状態が崩壊し、量子ビットの計算複雑性をもたらす重ね合わせが破壊されるからだ。\n",
"\n",
"特に、 $N$ -bit の量子状態 $\\vert \\psi\\rangle = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle$ が与えられた場合、測定によって、 $\\vert c_i\\vert ^2$ に等しい確率で、基底関数 $\\vert i\\rangle$ のいずれかに崩壊する。\n",
"\n",
"しかし、このような計測の破壊的な効果は、必ずしも妨げになるとは限らない。 実際、 [量子テレポーテーションや](/learning/modules/computer-science/quantum-teleportation) [量子鍵配布など](/learning/modules/computer-science/quantum-key-distribution)、特定のアルゴリズムやプロトコルにおいて重要なリソースとなっている。\n",
"\n",
"Qiskitでは、測定が行われると、それは古典レジスタに送られ、古典ビットとして保存される。 測定で回路を作ると次のようになる：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "56dfec5d-556b-486d-9cbf-0700582ec25c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(\n",
" 1, 1\n",
") # the second number is the number of classical bits in the circuit\n",
"qc.measure(0, 0)\n",
"qc.draw(\"mpl\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "45a53043-fdc8-4df2-b2c8-8b12ded1f400",
"metadata": {},
"source": [
"\n",
"\n",
"## 回路\n",
"\n",
"さて、量子ビット、ゲート、計測の仕組みがわかったところで、量子回路を自作して実行してみよう！ そのためには、Qiskitパターンと呼ばれる便利なワークフローを紹介する必要がある。\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a5adf2d9-4de5-4978-b509-05fb7381f238",
"metadata": {},
"source": [
"\n",
"\n",
"### Qiskitパターンフレームワーク\n",
"\n",
"Qiskitパターン・フレームワークは、量子コンピューターで問題に取り組み、解決するための一般的な手順である。 それは4つのステップからなる：\n",
"\n",
"1. 量子回路と量子演算子への問題の**マッピング**\n",
"2. ターゲット・ハードウェアに回路を**最適化する**\n",
"3. ターゲット・ハードウェア上での**実行**\n",
"4. 結果の**後処理**\n",
"\n",
"これらのステップを説明するために、上述した半加算回路の*量子*バージョンを実装する。\n",
"\n",
"\n",
"\n",
"#### 1. マッピング\n",
"\n",
"古典的な加算回路は、XORゲートとANDゲートを使って、それぞれ合計ビットとキャリービットを計算する。 これらのゲートを量子コンテキストに適応させれば、量子半加算器を作ることができる。 まず、量子ゲートが*可逆的*であることを思い出すと、単純に入力を上書きすることはできない。 その代わりに、 $\\vert 0\\rangle$ に初期化された2つのヘルパー量子ビットを導入し、合計とキャリー出力を保存する。 つまり、完全な量子状態は、 $A$ と $B$ の量子ビットと、 $S$ と $C$ の和量子ビットとキャリー量子ビットで構成されます：\n",
"\n",
"$\\vert \\psi\\rangle = \\vert C S B A\\rangle$\n",
"\n",
"さて、古典回路でXORゲートやANDゲートが行っていたことを実現する量子ゲートが必要だ。\n",
"\n",
"**合計:**\n",
"\n",
"XORには2つのCNOTを適用し、それぞれ制御量子ビット $A$、 $B$、ターゲット量子ビット $S$。 $A$ と $B$ が異なる場合、CNOTゲートの1つが $S$ を $\\vert 1\\rangle$ の状態に反転させる。 $A$ と $B$ がともに $\\vert 0\\rangle$ の場合、 $S$ には何も起こらず、 $\\vert 0\\rangle$ の状態のままとなる。 $A$ と $B$ がともに $\\vert 1\\rangle$ の場合、 $S$ の状態は2回反転し、 $\\vert 0\\rangle$ の状態に戻る。\n",
"\n",
"**キャリー**\n",
"\n",
"キャリー・ビットには、古典的なANDゲートのようなものが必要だ。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"これまで説明したゲートを振り返って、古典的なANDゲートの代わりにどの量子ゲートを使うかわかるだろうか：\n",
"\n",
"\n",
" \n",
" トフォリのゲートだ！ トッフォリ（制御-制御-NOT）ゲートは、制御量子ビット0と制御量子ビット1の両方が $\\vert 1\\rangle$ の場合にのみ、ターゲットの状態を反転させることを覚えておいてください。つまり、制御対象の量子ビットが $\\vert 0\\rangle$ の状態から始まる場合、ANDゲートと同じ動作をします。\n",
" \n",
"\n",
"\n",
"これで量子回路を作るのに必要な材料はすべて揃った：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "0bf14732-29fb-41c7-a4b3-94bd276ebc33",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# qubits: a, b, sum, carry\n",
"qc = QuantumCircuit(4)\n",
"\n",
"# Choose values for A and B:\n",
"a = 0\n",
"b = 0\n",
"\n",
"# Prepare A and B qubits according to selected values:\n",
"if a:\n",
" qc.x(0)\n",
"if b:\n",
" qc.x(1)\n",
"\n",
"# XOR (sum) into qubit 2\n",
"qc.cx(0, 2)\n",
"qc.cx(1, 2)\n",
"\n",
"# AND (carry) into qubit 3\n",
"qc.ccx(0, 1, 3) # a AND b\n",
"\n",
"# measure\n",
"qc.measure_all()\n",
"\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "cd129de5-0b73-44db-97ea-f819184e3661",
"metadata": {},
"source": [
"上の図は、量子半加算回路の回路図である。 前述したように、ワイヤーは上から下に並んだ量子ビット $0$ から $3$ を表し、古典的なビット・レジスタは一番下の二重に並んだワイヤーである。 次に、左から右へ読んでいき、対応するワイヤのどこにボックスが表示されているかを見ることで、ゲートがそれぞれの量子ビットにどのように適用されているかを確認する。 最後に測定結果を示す。 測定は量子ビットの状態を $0$ または $1$ の明確な値に分解し、その結果は古典的なレジスタに送られる。\n",
"\n",
"回路図は左から右に描かれているが、対応する行列式を書くときは右から左に読まなければならない。 これは、行列の乗算では、状態ベクトルに最も近い演算子が最初に作用するからである。 したがって、例えば上記の回路は（測定値を無視して）次のように書かれる：\n",
"\n",
"$$\n",
"CCNOT(q_0,q_1,q_3)CNOT(q_1, q_2)CNOT(q_0,q_2)\\vert q_3 q_2 q_1 q_0\\rangle\n",
"$$\n",
"\n",
"\n",
"\n",
"#### 2. 最適化：\n",
"\n",
"次に、量子ハードウェア上で動作するように回路を最適化する必要がある。 この最適化はトランスパイラによって達成され、トランスパイラは上に示した抽象的な回路を量子コンピューターが理解できる命令に変換する。 上記の論理的な量子ビットをプロセッサ上の実際の物理的な量子ビットに割り当て、量子コンピュータ上で動作するように最適化された独自のゲートセットでゲートを書き換える。 最後に、トランスパイラーは「エラーの抑制と緩和」と呼ばれるものも実装しており、エラーによる結果への影響を最小限に抑えようとしている。 しかし、量子コンピューティングの旅を続け、より複雑な回路を動かすようになれば、エラーの抑制と緩和の価値がすぐにわかるだろう。 これについてもっと学びたい方は、オリビア・レーンのコース『 [Quantum Computing in Practice](/learning/courses/quantum-computing-in-practice/introduction) 』をご覧ください。\n",
"\n",
"まず、 IBM® 量子コンピューターとの通信に必要なパッケージをロードし、実行するバックエンドを選択する。 最もビジーでないバックエンドを選ぶか、プロパティがわかっている特定のバックエンドを選ぶことができる。\n",
"\n",
"初回使用時に認証情報を保存するためのコードが以下にあります。 ノートブックを自分の環境に保存した後、必ずこの情報をノートブックから削除してください。そうすれば、ノートブックを共有するときにあなたの認証情報が誤って共有されることはありません。 詳しいガイダンスについては、 [IBM Cloud アカウントの設定](/docs/guides/cloud-setup)および[信頼できない環境でのサービスの初期](/docs/guides/cloud-setup-untrusted)化を参照してください。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bdc5e025-8bf4-4fbc-af80-4404e2577511",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_fez\n"
]
}
],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Load IBM Quantum Compute Service\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',\n",
"# instance = '', token='', overwrite=True, set_as_default=True)\n",
"# service = QiskitRuntimeService(channel='ibm_quantum_platform')\n",
"\n",
"# Load saved credentials\n",
"service = QiskitRuntimeService()\n",
"\n",
"# Use the least busy backend, or uncomment the loading of a specific backend like \"ibm_brisbane\".\n",
"backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n",
"# backend = service.backend(\"ibm_brisbane\")\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "4b4fb4cb-7e4a-47f4-a5d5-803b2d513a61",
"metadata": {},
"source": [
"次に、トランスパイラを使って回路を最適化する。 最適化レベルは0（最適化なし）から3（最高最適化）まで選択できる。 各レベルの内容については、 [Set transpiler optimization level](/docs/guides/set-optimization) guideをご覧ください。 出来上がった回路は、マッピングのステップで作った論理回路とは大きく異なるものになるだろう。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ad106853-7416-4fb9-b8e3-c43bb81c9059",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Transpile the circuit and optimize for running on the quantum computer selected\n",
"# Step 2: Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"\n",
"qc_isa.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "d9c345cf-9a25-4b6f-a5ec-62a6cefe3f27",
"metadata": {},
"source": [
"「サンプラー」とは、量子回路の結果として生じうる状態をサンプリングし、どのような状態がどの程度の確率で測定されるかに関する統計情報を収集するために設計されたプリミティブである。 ここで、 IBM Quantum サンプラーをインポートします：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "13a3faee-256d-4038-b0bf-ef1100139a96",
"metadata": {},
"outputs": [],
"source": [
"# Load the IBM Quantum primitive and session\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)"
]
},
{
"cell_type": "markdown",
"id": "3d392a16-51ae-4367-8b75-4abf520f6474",
"metadata": {},
"source": [
"実際の量子コンピュータで割り当てられた時間を使い果たした場合や、インターネットに接続できない場合は、シミュレータを使用することをお勧めします。 これを行うには、以下のセルを実行し、\"Execute \"ステップの関連行のコメントを外す。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "bcc1cab6-73db-4c8e-96b6-af7137ab6bd1",
"metadata": {},
"outputs": [],
"source": [
"# Load the backend sampler\n",
"from qiskit.primitives import BackendSamplerV2\n",
"\n",
"# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"# Define a simulator using Aer, and use it in Sampler.\n",
"backend_sim = AerSimulator(noise_model=noise_model)\n",
"sampler_sim = BackendSamplerV2(backend=backend_sim)\n",
"\n",
"# Alternatively, load a fake backend with generic properties and define a simulator.\n",
"# backend_gen = GenericBackendV2(num_qubits=18)\n",
"# sampler_gen = BackendSamplerV2(backend=backend_gen)"
]
},
{
"cell_type": "markdown",
"id": "6112fb67-3f51-4532-bb30-331b687cb43d",
"metadata": {},
"source": [
"\n",
"\n",
"#### 3. 実行\n",
"\n",
"回路を準備したら、今度は量子コンピューターで走らせてみよう！\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "0609b820-bb46-4a00-b33b-813ce8843ae1",
"metadata": {},
"outputs": [],
"source": [
"job = sampler.run([qc_isa], shots=100)\n",
"# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator\n",
"res = job.result()\n",
"counts = res[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "fea26bd9-84c9-402f-bd7e-785754993af9",
"metadata": {},
"source": [
"\n",
"\n",
"#### 4. 後処理\n",
"\n",
"これで結果を見る準備ができた！ 回路の100サンプルのヒストグラムを表示します。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "a4efc93d-ed2e-406f-b335-deeaa661c55b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"counts = {'0000': 90, '0100': 4, '1100': 3, '0010': 3}\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_histogram\n",
"\n",
"print(\"counts = \", counts)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "c228359b-7022-426a-ae7f-3599efb2231e",
"metadata": {},
"source": [
"上のヒストグラムは、回路終了時の4つの量子ビットすべての測定結果を示している。 ノイズがゼロの理想的な量子コンピューターであれば、量子ビットの測定値は毎回同じ値になるはずだが、現実にはノイズによって誤差が生じるものもある。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"$A$, $B$, $S$, $C$ の値として最もカウント数の多いビット列を使用し、量子加算回路が動作したことを確認する。\n",
"\n",
"\n",
" \n",
" $A+B = S+2 \\times C$ を検証する必要がある。ビット文字列の順序はリトルエンディアン表記に従うので、 `CSBA` を読むことを覚えておいてほしい。\n",
"\n",
" 上のヒストグラムから、 `0000` のビット列が支配的であることがわかる。\n",
"\n",
" $0 + 0 = 0 + 0 \\times 2 = 0 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"戻って $A$ と $B$ の値を $A=1$ と $B=1$ に変更し、Qiskitパターンの手順をもう一度行って回路を再実行する。 加算回路が再び機能したことを確認する。\n",
"\n",
"\n",
" \n",
" 優勢なビット列が `1011` であるヒストグラムが得られるはずである：\n",
"\n",
" $1 + 1 = 0 + 1 \\times 2 = 2 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"古典的な半加算器に対する*量子*半加算器の追加機能のひとつは、 *量子*入力で実行できることである。 つまり、量子ビット $A$ と $B$ が重ね合わせ状態であっても、「加算」することができる。 以下のチャレンジ・クエスチョン・セクションでは、量子ビットを重ね合わせた状態で用意し、何が起こるかを見てもらいます！\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ca1d1257-d741-4f46-908b-73cef6bc8fc7",
"metadata": {},
"source": [
"\n",
"\n",
"## おわりに\n",
"\n",
"このモジュールは、量子コンピューティングを古典コンピューティングと比較することで、量子コンピューティングの背後にある基本原理をしっかりと基礎から理解できるように設計されている。 私たちは古典的な半加算回路を見て、その回路を量子コンピュータの量子ビットで動作するように適応させる方法を紹介した。 これで、他のQiskit in the Classroomモジュールを探索する準備が整いました！\n",
"\n",
"\n",
"\n",
"### 重要な概念：\n",
"\n",
"* 0と1しか取ることができない古典的なビットとは対照的に、量子ビットは0と1の**重ね合わせ**状態になることもできる。\n",
"* 複数の量子ビットは、 **計算基底状態と**呼ばれる古典的に許容されるビット列上の重ね合わせ状態にあることができる。\n",
"* 複数の量子ビットを**エンタングルして**、一方の状態が他方の状態に依存するようにすることができる。\n",
"* Qiskitの慣例では**リトルエンディアン表記を**使用し、最下位量子ビット $q_0$ を右端に、最上位量子ビット $q_N$ を左端に配置する。\n",
"* **量子ゲートは**、量子状態ベクトルに作用するユニタリー行列で表される可逆演算である。 この表記では、ベクトルに最も近い行列（最も右にある行列）が最初に作用する。\n",
"* **測定は**、量子的な重ね合わせ状態を、古典的に許容される状態の1つに崩壊させる。\n",
"* 量子回路は**量子回路図を使って**表現されることが多く、量子ビットは横線のように描かれ、量子ゲートはこの横線に沿って左から右へと現れる。\n",
"* 量子回路を実行するには、 **Qiskitパターンの**ワークフローにある4つのステップを使用する： **マップ**、 **最適化**、 **実行**、 **後処理**。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "34ccee8d-e9cc-45eb-ab30-8e8160ec9a5b",
"metadata": {},
"source": [
"\n",
"\n",
"## 質問\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37265ba8-dc01-4aae-941f-6e051c62d7cc",
"metadata": {},
"source": [
"\n",
"\n",
"### 正誤問題\n",
"\n",
"1. 古典的なコンピュータの1ビットは、0か1しか保持できない。\n",
"\n",
"2. エンタングルメントとは、ある量子ビットの状態が別の量子ビットの状態から独立していることを意味する。\n",
"\n",
"3. 量子ゲートは一般に不可逆演算である。\n",
"\n",
"4. Qiskitの慣例では、最下位量子ビット（ $q_0$ ）を左端に配置する。\n",
"\n",
"5. 量子状態を測定すると、何度繰り返してもまったく同じ結果が得られる。\n",
"\n",
"6. ハダマードゲートは、1つの量子ビットに重ね合わせを作り出す。\n",
"\n",
"7. 量子回路は、重ね合わせ状態を古典的に許容される状態のいずれかに崩壊させる測定操作を含むことができる。\n",
"\n",
"8. $N$ ビットに対して可能な古典的状態の数は $2N$ である。\n",
"\n",
"9. 量子測定の結果確率は、古典的に測定可能な基底状態の振幅の2乗によって与えられる。\n",
"\n",
"\n",
"\n",
"### 短答問題\n",
"\n",
"1. ビットと量子ビットの主な違いは何ですか？\n",
"\n",
"2. 量子状態を測定するとどうなるのか？\n",
"\n",
"3. Qiskitではなぜリトルエンディアン表記なのですか？\n",
"\n",
"4. Qiskitパターンのワークフローにおける4つのステップとは何ですか？\n",
"\n",
"\n",
"\n",
"### チャレンジ問題：\n",
"\n",
"1. モジュールでは、 $A$ と $B$ について、古典的に許容される状態を加算するために加算器を使っただけである。しかし、 $A$ と $B$ を重ね合わせることもできる！ それぞれの量子ビットが0と1の等しい重ね合わせになるようにコードを変更し、新しい回路を実行し、新しいヒストグラムを得る。 何が見える？ 何が起きているのかを説明する。\n",
"\n",
"2. トッフォリ・ゲート分解。 `decompose()` 、トッフォリ・ゲートがどのように1qubitゲートと2qubitゲートに分解されるかを示し、行列乗算でこの構成を検証する。 回路図は左から右に読むが、行列は右から左に量子状態に適用されることを覚えておいてほしい！\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"in_page_toc_max_heading_level": 2,
"in_page_toc_min_heading_level": 2,
"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"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}