{
"cells": [
{
"cell_type": "markdown",
"id": "e98de65a",
"metadata": {},
"source": [
"---\n",
"title: \"グローバーのアルゴリズム\"\n",
"description: \"グローバーのアルゴリズムが量子コンピューティングを用いて非構造化検索問題を解決する方法を学びましょう。\"\n",
"---\n",
"\n",
"{/* cspell:ignore bitstr */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9857bace",
"metadata": {},
"source": [
"\n",
"\n",
"# グローバーのアルゴリズム\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5c6854a5",
"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 Quantum® のアカウントを設定する必要があります。 [IBM Cloud アカウントの設定](/docs/guides/cloud-setup)ガイドの手順に従ってください。\n",
"\n",
"このモジュールはテストされ、12秒のQPU時間を使用した。 これは善意の見積もりであり、実際の使用量は異なる場合があります。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e16858b0",
"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": "e57d1e6b",
"metadata": {},
"source": [
"\n",
"\n",
"## 概要\n",
"\n",
"**グローバーのアルゴリズムは**、 *構造化されていない探索問題を*扱う量子アルゴリズムの基礎となるものである。 $N$ のアイテムの集合と、あるアイテムが探しているものであるかどうかをチェックする方法が与えられたとき、目的のアイテムをどれだけ速く見つけられるか？ 古典的なコンピューティングでは、データがソートされておらず、利用できる構造がない場合、最適なアプローチは各アイテムを1つずつチェックすることであり、クエリの複雑さは $O(N)$。\n",
"\n",
"\n",
"\n",
"1996年にLov Groverが発表したGroverのアルゴリズムは、量子コンピューターがこの問題をはるかに効率的に解く方法を示しており、マークされたアイテムを高確率で見つけるのに必要なステップはわずか $O(\\sqrt{N})$。 これは古典的な方法に比べて *2次関数的なスピードアップ*であり、大規模なデータセットでは重要である。\n",
"\n",
"このアルゴリズムは次のような文脈で動作する：\n",
"\n",
"* **問題の設定：** $x$ が欲しいアイテムであれば 1 を、そうでなければ 0 を返す関数 $f(x)$ がある。 この関数は、しばしば*オラクル*または*ブラックボックスと*呼ばれる。なぜなら、 $f(x)$ に問い合わせることによってのみ、データについて知ることができるからである。\n",
"* **量子の有用性：** この問題に対する古典的アルゴリズムが平均して $N/2$ クエリーを必要とするのに対し、Groverのアルゴリズムはおおよそ $\\pi\\sqrt{N}/4$ クエリーで解を求めることができ、これは $N$ が大きい場合にははるかに高速である。\n",
"* **どのように機能するか（ハイレベルで）：**\n",
" * 量子コンピューターはまず、すべての可能な状態の*重ね合わせを*作成し、すべての可能な項目を一度に表現する。\n",
" * そして、正解の確率を増幅し、それ以外の確率を減少させる一連の量子演算（グローバー反復）を繰り返し適用する。\n",
" * 十分な反復の後、量子状態を測定すると、高い確率で正しい答えが得られる。\n",
"\n",
"以下はグローバーのアルゴリズムの非常に基本的な図である。 より詳細な図については、 [本稿を](https://arxiv.org/pdf/2211.04543)参照されたい。\n",
"\n",
"\n",
"\n",
"グローバーのアルゴリズムについていくつか注意すべき点がある：\n",
"\n",
"* これは構造化されていない検索に最適である。どの量子アルゴリズムも、 $O(\\sqrt{N})$ より少ないクエリーで問題を解くことはできない。\n",
"* これは、他の量子アルゴリズム（例えば、因数分解のためのショールのアルゴリズム）とは異なり、指数関数的ではなく、2次関数的なスピードアップしかもたらさない。\n",
"* 暗号システムに対するブルートフォース攻撃を高速化できる可能性があるなど、実用的な意味合いを持つが、高速化だけでは最新の暗号のほとんどを解読できるほどではない。\n",
"\n",
"基本的なコンピューティングの概念やクエリーモデルに精通した学部生にとって、グローバーのアルゴリズムは、量子コンピューティングが特定の問題において、たとえ \"たった \"2次関数的な改善であったとしても、いかに古典的なアプローチを上回ることができるかを明確に示している。 また、より高度な量子アルゴリズムや量子コンピューティングの幅広い可能性を理解するための入り口としても役立つ。\n",
"\n",
"振幅増幅は汎用の量子アルゴリズム（サブルーチン）であり、これを使用することで、一握りの古典的アルゴリズムを2次関数的に高速化することができる。 [グローバーのアルゴリズムは](https://arxiv.org/abs/quant-ph/9605043)、構造化されていない探索問題で初めてこの高速化を実証した。 グローバーの探索問題を定式化するには、1つ以上の計算基底状態を見つけたい状態としてマークするオラクル関数と、マークされた状態の振幅を増大させ、結果として残りの状態を抑制する増幅回路が必要である。\n",
"\n",
"ここでは、グローバー・オラクルの構築方法と、Qiskit回路ライブラリ `GroverOperator` の機能を活用して、グローバー探索インスタンスを簡単にセットアップする方法について解説します。 IBM Quantum`Sampler` プリミティブを使用すると、Grover回路をシームレスに実行できます。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "4f900ae6",
"metadata": {},
"source": [
"\n",
"\n",
"## 理論\n",
"\n",
"バイナリ文字列を単一のバイナリ変数にマップする関数 $f$ が存在するとする\n",
"\n",
"$$\n",
"f: \\Sigma^n \\rightarrow \\Sigma\n",
"$$\n",
"\n",
"$\\Sigma^6$\n",
"\n",
"$$\n",
"f(x)= \\begin{cases} 1 \\qquad \\text{if }x=\\{010101\\}\\\\\n",
"0 \\qquad \\text{otherwise }\n",
"\\end{cases}\n",
"$$\n",
"\n",
"$\\Sigma^{2n}$ で定義されている別の例は以下の通り\n",
"\n",
"$$\n",
"f(x)= \\begin{cases} 1 \\qquad \\text{if equal numbers of 1's and 0's in string}\\\\\n",
"0 \\qquad \\text{otherwise }\n",
"\\end{cases}\n",
"$$\n",
"\n",
"あなたには、 $f(x)$ の引数 $x$ のうち、1に対応する量子状態を見つけるという課題がある。 言い換えれば、 $f(x_1)=1$ （または解がない場合はその旨を報告する）ような $\\{x_1\\}\\in \\Sigma^n$ をすべて見つける。 解でないものを $x_0$ と呼ぶ。もちろん、私たちは量子コンピュータ上で量子状態を用いてこれを行うので、これらの2進文字列を状態として表現することは有用である：\n",
"\n",
"$$\n",
"\\{|x_1\\rangle\\} \\in |\\Sigma^n\\rangle\n",
"$$\n",
"\n",
"量子状態（ディラック）記法を用いると、1つ以上の特別な状態 $\\{|x_1\\rangle\\}$ を、 $N=2^n$ 可能な状態の集合の中から探すことになる。 $n$ は量子ビットの数で、非解は次のように表される。 $\\{|x_0\\rangle\\}.$\n",
"\n",
"関数 $f$ は、オラクルによって提供されるものと考えることができる。ブラックボックスで、状態 $|x\\rangle.$ に対する効果を決定するために問い合わせることができる。実際には、関数を知っていることが多いが、実装が非常に複雑な場合がある。つまり、問い合わせや $f$ の適用回数を減らすことが重要になる。 別の方法として、ある人が別の人がコントロールするオラクルに問い合わせるというパラダイムを想像することができる。\n",
"\n",
"これは「構造化されていない検索問題」であり、 $f$、検索に役立つ特別なものは何もない。 出力はソートされておらず、解のクラスタリングなども知られていない。 古い紙の電話帳を例えて考えてみよう。 この非構造化検索は、特定の**番号を探して**スキャンするようなもので、アルファベット順に並んだ名前のリストを探すようなものではない。\n",
"\n",
"単一の解を求める場合、古典的には、 $N$ に線形な数のクエリーを必要とする。明らかに、最初の試行で解が見つかるかもしれないし、最初の $N-1$ 推測で解が見つからないかもしれない。そのような場合は、 $N^{th}$ 入力に問い合わせをして、解があるかどうかを確認する必要がある。 関数には悪用可能な構造がないため、平均して $N/2$。 Groverのアルゴリズムは、 $f$ のクエリーや計算の回数を必要とするが、これは次のようにスケールする。 $\\sqrt{N}.$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a1a51eb6",
"metadata": {},
"source": [
"\n",
"\n",
"### グローバーアルゴリズムにおける回路の概略図\n",
"\n",
"グローバーのアルゴリズムの完全な数学的ウォークスルーは、例えば、ジョン・ワトラスによるコース「 [Fundamentals of quantum algorithms](/learning/courses/fundamentals-of-quantum-algorithms) 」（ IBM Quantum Learning）で見ることができる。 このモジュールの最後には、付録として凝縮された処置が提供されている。 しかし今は、グローバーのアルゴリズムを実装する量子回路の全体的な構造をおさらいするにとどめる。\n",
"\n",
"グローバーのアルゴリズムは以下の段階に分けられる：\n",
"\n",
"* 初期重ね合わせの準備（すべての量子ビットにハダマードゲートを適用する）\n",
"* 位相反転でターゲット状態を「マーク」する\n",
"* ハダマードゲートと位相反転が**すべての**量子ビットに適用される「拡散」ステージ。\n",
"* 目標状態を測定する確率を最大にするために、マーキングと拡散の段階を繰り返す可能性\n",
"* 寸法\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "15b9e48c",
"metadata": {},
"source": [
"多くの場合、マーキングゲート $Z_f$、 $H,$ $Z_{\\text{OR}},$、 $H$ からなる拡散層を総称して「グローバー・オペレーター」と呼ぶ。 この図では、グローバー演算子の繰り返しが1回だけ示されている。\n",
"\n",
"ハダマードゲート $H$ はよく知られており、量子コンピューティングで広く使われている。 ハダマードゲートは重ね合わせ状態を作り出す。 具体的には、次のように定義される\n",
"\n",
"$$\n",
"H|0\\rangle = \\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)\\\\\n",
"H|1\\rangle = \\frac{1}{\\sqrt{2}}\\left(|0\\rangle-|1\\rangle\\right)\n",
"$$\n",
"\n",
"それ以外の状態での動作は、線形性によって定義される。\n",
"特に、ハダマードゲートのレイヤーによって、すべての量子ビットが $|0\\rangle$ （ $|0\\rangle^{\\otimes n}$ ）にある初期状態から、各量子ビットが $|0\\rangle$ または $|1\\rangle;$ のいずれかで測定される確率を持つ状態に移行することができ、古典的な計算とは異なる方法で、すべての可能な状態の空間を探ることができる。\n",
"\n",
"ハダマードゲートの重要な付随的性質は、2回目に作用すると、このような重ね合わせ状態を元に戻すことができるということである：\n",
"\n",
"$$\n",
"H\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)=|0\\rangle\\\\\n",
"H\\frac{1}{\\sqrt{2}}\\left(|0\\rangle-|1\\rangle\\right)=|1\\rangle\n",
"$$\n",
"\n",
"これはすぐに重要になる。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"ハダマードゲートの定義から出発して、ハダマードゲートの2回目の適用が、上記のような重ね合わせを元に戻すことを示す。\n",
"\n",
"\n",
" \n",
" Xを $|+\\rangle$ の状態に適用すると、値と+1が得られ、 $|-\\rangle$ の状態に適用すると、 -1 が得られる。したがって、分布が半々であれば、期待値は0となる。\n",
" \n",
"\n",
"\n",
"$Z_\\text{OR}$ ゲートはあまり一般的ではなく、次のように定義される\n",
"\n",
"$$\n",
"\\text{Z}_\\text{OR}|x\\rangle = \\begin{cases}\n",
"|x\\rangle & \\text{if } x = 0^n \\\\\n",
" -|x\\rangle & \\text{if } x \\neq 0^n\n",
"\\end{cases}\n",
"\\qquad \\forall x \\in \\Sigma^n\n",
"$$\n",
"\n",
"最後に、 $Z_f$ ゲートは次式で定義される\n",
"\n",
"$$\n",
"Z_f:|x\\rangle \\rightarrow (-1)^{f(x)}|x\\rangle \\qquad \\forall x \\in \\Sigma^n\n",
"$$\n",
"\n",
"この効果とは、 $Z_f$、 $f(x) = 1$ の対象状態の符号を反転させ、他の状態には影響を与えないということである。\n",
"\n",
"非常に高度で抽象的なレベルでは、回路のステップを次のように考えることができる：\n",
"\n",
"* 第一ハダマード層：量子ビットをすべての可能な状態の重ね合わせにする。\n",
"* $Z_f$ \"-\"記号を前に付けることで、対象となる状態（複数可）をマークする。 これはすぐに測定確率を変えるわけではないが、その後のステップでターゲット状態がどのように振る舞うかを変える。\n",
"* もうひとつのハダマード層：前のステップで導入した\"-\"記号は、いくつかの項間の相対符号を変更する。 ハダマードゲートは、ある混合計算状態 $(|0\\rangle+|1\\rangle)/\\sqrt{2}$ を一つの計算状態、 $|0\\rangle,$ に変え、 $(|0\\rangle-|1\\rangle)/\\sqrt{2}$ を $|1\\rangle$ に変えるので、この相対的な符号の違いは、どのような状態を測定するかで役割を果たし始めることができる。\n",
"* ハダマードゲートの最後のレイヤーが適用され、測定が行われる。\n",
" この仕組みについては、次のセクションで詳しく説明する。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bf41c02c",
"metadata": {},
"source": [
"\n",
"\n",
"### 例\n",
"\n",
"グローバーのアルゴリズムがどのように機能するかをよりよく理解するために、小さな2量子ビットの例を見てみよう。 量子力学やディラック記法に関心のない方には、オプションとしてお薦めする。 しかし、量子コンピューターで実質的な仕事をしたいと考えている人には、この本を強くお勧めする。\n",
"\n",
"以下は、量子状態をさまざまな位置にラベル付けした回路図である。 量子ビットが2つしかない場合、どのような状況でも測定可能な状態は4つしかないことに注意： $|00\\rangle$ $|01\\rangle$、 $|10\\rangle$、 $|11\\rangle$。\n",
"\n",
"\n",
"\n",
"ここで、オラクル（ $Z_f$、我々には未知）が状態 $|01\\rangle$ をマークしたと仮定する。オラクルを含む量子ゲートの各セットの動作を通して、測定時にどのような状態の分布が得られるかを見る。\n",
"冒頭で\n",
"\n",
"$$\n",
"|\\psi_0\\rangle = |00\\rangle\n",
"$$\n",
"\n",
"ハダマードゲートの定義を用いると、次のようになる\n",
"\n",
"$$\n",
"|\\psi_1\\rangle = \\frac{1}{2}\\left(|0\\rangle+|1\\rangle\\right)\\left(|0\\rangle+|1\\rangle\\right)=\\frac{1}{2}\\left(|00\\rangle+|01\\rangle+|10\\rangle+|11\\rangle\\right)\n",
"$$\n",
"\n",
"これでオラクルはターゲット状態をマークする：\n",
"\n",
"$$\n",
"|\\psi_2\\rangle = \\frac{1}{2}\\left(|00\\rangle-|01\\rangle+|10\\rangle+|11\\rangle\\right)\n",
"$$\n",
"\n",
"この状態では、4つの可能性のある結果がすべて同じ確率で測定されることに注意。 これらはすべてマグニチュード $1/2,$ の重みがあり、それぞれ $|1/2|^2=1/4$ の確率で測定されることを意味する。 つまり、状態 $|01\\rangle$ は\"-\"の段階を経てマークされているが、その状態を測定する確率はまだ上がっていない。 ハダマードゲートの次のレイヤーを適用する。\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"|\\psi_3\\rangle = &\\frac{1}{4}\\left(|00\\rangle+|01\\rangle+|10\\rangle+|11\\rangle\\right)\\\\\n",
"-&\\frac{1}{4}\\left(|00\\rangle-|01\\rangle+|10\\rangle-|11\\rangle\\right)\\\\\n",
"+&\\frac{1}{4}\\left(|00\\rangle+|01\\rangle-|10\\rangle-|11\\rangle\\right)\\\\\n",
"+&\\frac{1}{4}\\left(|00\\rangle-|01\\rangle-|10\\rangle+|11\\rangle\\right)\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"似たような項を組み合わせると、次のようになる\n",
"\n",
"$$\n",
"|\\psi_3\\rangle = \\frac{1}{2}\\left(|00\\rangle+|01\\rangle-|10\\rangle+|11\\rangle\\right)\n",
"$$\n",
"\n",
"現在、 $Z_{\\text{OR}}$ は、 $|00\\rangle$ を除く全州の看板をひっくり返している：\n",
"\n",
"$$\n",
"|\\psi_4\\rangle = \\frac{1}{2}\\left(|00\\rangle-|01\\rangle+|10\\rangle-|11\\rangle\\right)\n",
"$$\n",
"\n",
"そして最後に、ハダマードゲートの最後のレイヤーを適用する：\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"|\\psi_5\\rangle =&\\frac{1}{4}\\left(|00\\rangle+|01\\rangle+|10\\rangle+|11\\rangle\\right)\\\\\n",
"-&\\frac{1}{4}\\left(|00\\rangle-|01\\rangle+|10\\rangle-|11\\rangle\\right)\\\\\n",
"+&\\frac{1}{4}\\left(|00\\rangle+|01\\rangle-|10\\rangle-|11\\rangle\\right)\\\\\n",
"-&\\frac{1}{4}\\left(|00\\rangle-|01\\rangle-|10\\rangle+|11\\rangle\\right)\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"これらの用語の組み合わせを通して、結果が確かにそうであることを納得する価値がある：\n",
"\n",
"$$\n",
"|\\psi_5\\rangle =|01\\rangle\n",
"$$\n",
"\n",
"つまり、 $|01\\rangle$ （ノイズやエラーがない場合）を測定する確率は100％であり、それ以外の状態を測定する確率はゼロである。\n",
"\n",
"この2量子ビットの例は、特にクリーンなケースである。グローバーのアルゴリズムは、常に100％の確率で目標状態を測定できるとは限らない。 むしろ、目標状態を測定する確率を増幅させることになる。 また、グローバー・オペレーターは複数回繰り返す必要があるかもしれない。\n",
"\n",
"次のセクションでは、このアルゴリズムを実際の IBM® 量子コンピュータを使って実践してみる。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "geo_picture_01",
"metadata": {},
"source": [
"\n",
"\n",
"### 幾何学的な図\n",
"\n",
"上記の2量子ビットの例は、単純なケースにおける代数の働きを示したものですが、グローバーのアルゴリズムを理解するには、もっと直感的な方法があります。それは、2次元平面における一連の幾何学的反射として捉えることです。 以下に、この図について説明します。 詳細については、ジョン・ワトラウス氏の講座 [「量子アルゴリズムの基礎」](/learning/courses/fundamentals-of-quantum-algorithms/grover-algorithm/analysis) もご参照ください。\n",
"\n",
"**飛行機の準備。** 初期の重ね合わせ状態 $|\\psi\\rangle$ を2つの成分に分解することができる。 私たちが探している「正しい状態」を、 $|A_1\\rangle$ と呼ぶ。それ以外のすべての状態をまとめて、 $|A_0\\rangle$ と呼ぶ。定義上、 $|A_1\\rangle$ と $|A_0\\rangle$ は互いに直交しているため、抽象的な2次元空間において、これらを垂直な軸としてプロットすることができる。 $|\\psi\\rangle$ はこれら2つの成分の線形結合であるため、 $|A_0\\rangle$ 軸に対して $\\theta$ というわずかな角度をなしています。これは $|A_0\\rangle$ に近い値となります。なぜなら、初期状態では、正しい成分 $|A_1\\rangle$ にある状態の割合はごくわずかだからです。\n",
"\n",
"**思い返して。** ここで必要な重要な数学的事実は、次のような形の演算子が\n",
"\n",
"$$\n",
"2|v\\rangle\\langle v| - I\n",
"$$\n",
"\n",
"は、 $|v\\rangle.$ で定義される軸に関する任意の状態を反映している。その理由を理解するために、2つのケースを考えてみよう。 $|v\\rangle$ に沿った状態は変化しないが、 $|v\\rangle$ に垂直な状態は符号が反転する。 他のどの状態もこれら2つの要素に分解することができ、演算子はそれぞれに応じて作用する。これはまさに、 $|v\\rangle$ に対する反射である。\n",
"\n",
"実は、グローバーのアルゴリズムにおけるオラクル段階と拡散段階の両方が、この幾何学的図式において反射として表現できることがわかった。\n",
"\n",
"**鏡としての神託。** この関数は、 $|A_1\\rangle$ の状態フラグを反転させ、それ以外の部分は変更しません。 それは、 $|A_0\\rangle$ 軸に対する反射と同じです。\n",
"\n",
"\n",
"\n",
"**反射としての拡散。** 拡散演算子がどのようにして反射でもあるのかを理解するのは、少し難しい。 拡散演算子は\n",
"\n",
"$$\n",
"H^{\\otimes n}\\, Z_{\\text{OR}}\\, H^{\\otimes n}\n",
"$$\n",
"\n",
"$Z_{\\text{OR}}$ それ自体は全ゼロ状態に対する反射であり、 $|0\\rangle^{\\otimes n}$ 以外のすべての状態の符号を反転させる。これは、 $2|0\\rangle\\langle 0| - I$ と表すことができる。周囲のハダマール層は、事実上、基底変換を行い、反射軸を変換する。 $H^{\\otimes n}$ は、 $|0\\rangle^{\\otimes n}$ を一様重ね合わせ $|u\\rangle = \\frac{1}{\\sqrt{N}}\\sum_{x}|x\\rangle$ に写像することを思い出してください。ハダマール演算はそれ自体の逆演算であるため、式全体は次のようになります\n",
"\n",
"$$\n",
"H^{\\otimes n}\\left(2|0\\rangle\\langle 0| - I\\right)H^{\\otimes n} = 2|u\\rangle\\langle u| - I\n",
"$$\n",
"\n",
"これは、 $|u\\rangle$ に関する反射です。 $|u\\rangle$ は $|\\psi\\rangle$ に非常に近く（どちらも $|A_0\\rangle$ にほぼ沿っています）、この2回目の反射により、状態は出発点から $2\\theta$ の角度だけずれた位置へと送られます。\n",
"\n",
"\n",
"\n",
"**$2\\theta$ による回転。** これら2つの反射の複合効果は、 $2\\theta$ から $|A_1\\rangle$ への回転となる。Grover演算子の各反復ごとに、状態はさらに $2\\theta.$ だけ回転する\n",
"\n",
"**反復の最適回数。** 私たちの目標は、状態を $|A_1\\rangle$ にできるだけ近づけるように回転させることです。つまり、合計で約 $\\pi/2$ ラジアン（4分の1回転）回転させることになります。 各反復が $2\\theta$ を寄与する場合、最適な反復回数 $t$ は次の条件を満たす\n",
"\n",
"$$\n",
"(2t + 1)\\theta \\approx \\frac{\\pi}{2}\n",
"$$\n",
"\n",
"$N$ の条件を満たす解が1つだけ存在する場合、初期角は $\\theta \\approx \\sin^{-1}(1/\\sqrt{N}) \\approx 1/\\sqrt{N}$ となる（ $N$ が十分に大きい場合）。これを代入すると、\n",
"\n",
"$$\n",
"t \\approx \\frac{\\pi}{4}\\sqrt{N} - \\frac{1}{2}\n",
"$$\n",
"\n",
"ここで、あの有名な $\\sqrt{N}$ による計算速度向上の理由が明らかになります。つまり、目標値に到達するために必要な反復回数は $O(\\sqrt{N})$ 回だけで済み、従来の探索法で必要とされる $O(N)$ 回のチェックを行う必要がないのです。\n",
"\n",
"より一般に、 $N$ 個の総状態のうち、 $|A_1|$ 個の解状態が存在する場合、最適な反復回数は\n",
"\n",
"$$\n",
"t \\approx \\frac{\\pi}{4}\\sqrt{\\frac{N}{|A_1|}} - \\frac{1}{2}\n",
"$$\n",
"\n",
"反復回数を多くしすぎると、 $|A_1\\rangle$ を超えて回転し、目標状態が見つかる確率が再び低下し始めることに注意してください。 適切な反復回数を決定することは重要ですが、ノイズの多い量子ハードウェアでは、実験的に最適な回数はこの理想的な式とは異なる場合があります。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "3fd8fbb3",
"metadata": {},
"source": [
"\n",
"\n",
"### グローバーのアルゴリズムはなぜ有用なのでしょうか？\n",
"\n",
"ここで疑問に思うかもしれません。「目標状態を示すオラクルを作ったばかりなのに、それを作るためには、そもそもその目標状態を知っていなければならなかったのではないか」と。 では、私たちは一体何を探しているのでしょうか？\n",
"\n",
"これは妥当な質問であり、いくつかの良い答えがあります。\n",
"\n",
"* **クエリモデルは理論的なツールである。** 計算のクエリモデルは、もともと実用的なものとして設計されたわけではない。 その目的は、問題を「オラクル」と「それ以外」の2つの部分に分けることで、アルゴリズムの計算量を明確に分析できるようにすることです。 確認は無料ですが、検索はどれほど大変なのでしょうか？ クエリの数は、入力のサイズに応じてどのように変化しますか？ 実際にこのような仕組みで動作するシステムは存在しないとしても、これらは有用な問いである。\n",
"\n",
"* これは、 **2人で行うアクティビティ**と捉えることもできます。一方が目標状態を把握し、オラクルを構築し、もう一方はそのオラクルをブラックボックスとして扱い、内部を覗き見することなく答えを見つけ出すのが役割となります。 以下のアクティビティ2では、パートナーと一緒にまさにこの作業を行います。\n",
"\n",
"* **振幅増幅は、幅広い用途に役立つサブルーチンです。** この最初のデモンストレーションは一見循環論法のように見えるかもしれませんが、その根底にある「 *振幅増幅* 」と呼ばれるメカニズムは、量子コンピューティングの分野で繰り返し現れます。 ここで私たちが実際に構築しているのは、より複雑な量子アルゴリズムの多くにおいてサブルーチンとして登場するツールに対する直感的な理解です。\n",
"\n",
"* **答えを知らなくてもオラクルを構築できる問題がある。** 重要な点は、解決策*を見つける*のは非常に難しい一方で、与えられた解決策が正しいかどうか*を確認*するのは極めて容易な問題という、ある種のカテゴリーが存在するということである。 ファクタリングはその一例です。2つの大きな素数の積が与えられた場合、それらの素数が何であるかを特定するのは極めて困難ですが、一度それらを特定できれば、それらを掛け合わせることで簡単に検証することができます。 （因数分解に関しては、グローバーのアルゴリズムよりも優れたアルゴリズムが存在します（ショアのアルゴリズムを参照）が、この機能の問題点はこれだけにとどまりません。） 数独や制約満足問題、さらには定番の「マインスイーパ」といったゲームも、すべて解くのは難しいが、正解かどうかを確認するのは簡単な問題です。\n",
"\n",
"それがなぜ重要なのでしょうか？ つまり、解答そのものは分からなくても、その解答が満たすべきすべての*条件*や*要件*を把握し、それらの要件をオラクルとして機能する量子回路に組み込むことができるということです。 グローバーのアルゴリズムがそれを求めてくれます。\n",
"\n",
"これらの点を踏まえて、いくつかの例を見ていきましょう。 アルゴリズムの論理を追えるよう、解の状態が明確に指定されている例から始めます。 次に、2人で行うアクティビティに進み、最後に、答えの知識ではなく問題の制約条件に基づいてオラクルを構築する例を取り上げます。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "90cfe463",
"metadata": {},
"source": [
"\n",
"\n",
"### 一般的な輸入とアプローチ\n",
"\n",
"まずは必要なパッケージをいくつかインポートする。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "27a7cc58",
"metadata": {},
"outputs": [],
"source": [
"# Built-in modules\n",
"import math\n",
"\n",
"# Imports from Qiskit\n",
"from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
"from qiskit.circuit.library import grover_operator, MCMTGate, ZGate\n",
"from qiskit.visualization import plot_distribution\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager"
]
},
{
"cell_type": "markdown",
"id": "0d5be4ca",
"metadata": {},
"source": [
"このチュートリアルや他のチュートリアルでは、「Qiskitパターン」として知られる量子コンピューティングのフレームワークを使用します：\n",
"\n",
"* ステップ1：古典的入力を量子問題にマップする\n",
"* ステップ2：量子実行のための問題の最適化\n",
"* ステップ 3: `IBM Quantum` プリミティブを使用して実行する\n",
"* ステップ4：後処理と古典的分析\n",
"\n",
"私たちは通常、これらのステップに従うが、必ずしも明示的にラベルを貼るとは限らない。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5e1d0a46",
"metadata": {},
"source": [
"\n",
"\n",
"## アクティビティ1: 単一の与えられた目標状態を見つける\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "23b5217f",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ1：古典的な入力を量子問題にマッピングする\n",
"\n",
"位相クエリーゲートは、解決状態に全体的な位相 (-1)、非解決状態には影響を与えないようにする必要がある。 別の言い方をすれば、グローバーのアルゴリズムは、1つ以上のマークされた計算基底状態を指定するオラクルを必要とする。ここで「マークされた」とは、 -1 の位相を持つ状態を意味する。 これは、制御されたZゲート、または $N$ 量子ビット上のマルチ制御一般化を用いて行われる。 これがどのように機能するかを見るために、ビット列の具体例を考えてみよう `{110}`。 $|\\psi\\rangle = |q_2,q_1,q_0\\rangle$、 $|\\psi\\rangle = |011\\rangle$ （Qiskitでは最下位（多くの場合0）量子ビットを右に置く表記になっているため、2進文字列の順序を反転させている）の場合に位相を適用する回路が欲しい。\n",
"\n",
"したがって、 $Z_f$\n",
"\n",
"$$\n",
"Z_f|\\psi\\rangle = \\begin{cases} -|\\psi\\rangle \\qquad \\text{if} \\qquad |\\psi\\rangle = |011\\rangle \\\\ |\\psi\\rangle \\qquad \\text{if} \\qquad |\\psi\\rangle \\neq |011\\rangle\\end{cases}\n",
"$$\n",
"\n",
"マルチプルコントロール・マルチプルターゲート(`MCMTGate`)を使用して、すべての量子ビットによって制御されるZゲートを適用することができます（すべての量子ビットが $|1\\rangle$ の状態にある場合、位相を反転させます）。 もちろん、希望する状態の量子ビットの一部は $|0\\rangle$。したがって、そのような量子ビットに対しては、まずXゲートを適用し、次に多重制御Zゲートを行い、さらにXゲートを適用して変更を元に戻さなければならない。 `MCMTGate` ：\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "66aeceae",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mcmt_ex = QuantumCircuit(3)\n",
"mcmt_ex.compose(MCMTGate(ZGate(), 3 - 1, 1), inplace=True)\n",
"mcmt_ex.draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "03b992b2",
"metadata": {},
"source": [
"多くの量子ビットが制御プロセスに関与している可能性があるが（ここでは3つの量子ビットが関与している）、単一の量子ビットがターゲットとして示されているわけではないことに注意。 ゲートはすべての量子ビットに等価に作用する。 これは、 `CX` ゲートのような、1つの制御量子ビットと1つのターゲット量子ビットを持つ他の多くの多重量子ビットゲートとは異なる。\n",
"\n",
"つまり、ビット列表現で定義された1つまたは複数の入力基底状態をマークする。 マルチ制御Zゲートの実装にはMCMTゲートが使用される。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "53f8763f",
"metadata": {},
"outputs": [],
"source": [
"def grover_oracle(marked_states):\n",
" \"\"\"Build a Grover oracle for multiple marked states\n",
"\n",
" Here we assume all input marked states have the same number of bits\n",
"\n",
" Parameters:\n",
" marked_states (str or list): Marked states of oracle\n",
"\n",
" Returns:\n",
" QuantumCircuit: Quantum circuit representing Grover oracle\n",
" \"\"\"\n",
" if not isinstance(marked_states, list):\n",
" marked_states = [marked_states]\n",
" # Compute the number of qubits in circuit\n",
" num_qubits = len(marked_states[0])\n",
"\n",
" qc = QuantumCircuit(num_qubits)\n",
" # Mark each target state in the input list\n",
" for target in marked_states:\n",
" # Flip target bitstring to match Qiskit bit-ordering\n",
" rev_target = target[::-1]\n",
" # Find the indices of all the '0' elements in bitstring\n",
" zero_inds = [\n",
" ind for ind in range(num_qubits) if rev_target.startswith(\"0\", ind)\n",
" ]\n",
" # Add a multi-controlled Z-gate with pre- and post-applied X-gates (open-controls)\n",
" # where the target bitstring has a '0' entry\n",
" qc.x(zero_inds)\n",
" qc.compose(MCMTGate(ZGate(), num_qubits - 1, 1), inplace=True)\n",
" qc.x(zero_inds)\n",
" return qc"
]
},
{
"cell_type": "markdown",
"id": "7349dd38",
"metadata": {},
"source": [
"ここで、特定の「マークされた」状態をターゲットに選び、先ほど定義した関数を適用する。 どんな回路ができたか見てみよう。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "6cb8ce21",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"marked_states = [\"1110\"]\n",
"oracle = grover_oracle(marked_states)\n",
"oracle.draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "5632a1dd",
"metadata": {},
"source": [
"qubit1-3が $|1\\rangle$、qubit0が初期状態で $|0\\rangle$、最初のXゲートはqubit0を $|1\\rangle$、すべてのqubitが $|1\\rangle.$。これは、MCMTゲートが全体的な符号変化または位相反転を適用することを意味する。 それ以外の場合は、量子ビット1-3が $|0\\rangle$、または量子ビット0が $|0\\rangle$、位相フリップは適用されない。 この回路は、私たちが望む状態 $|0111\\rangle,$ またはビット列 `{1110}` を確かにマークすることがわかる。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "4cbe89d3",
"metadata": {},
"source": [
"完全なグローバー演算子は、位相問合せゲート（オラクル）、ハダマード層、 $Z_\\text{OR}$ 演算子で構成される。 上で定義したオラクルから、組み込みの `grover_operator` 。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "9426f7a5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grover_op = grover_operator(oracle)\n",
"grover_op.decompose(reps=0).draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "fb293e00",
"metadata": {},
"source": [
"前述の図で説明したように、グローバー演算子を複数回適用する必要があるかもしれません。 ノイズが存在しない場合に目標状態の振幅を最大化する最適な反復回数 $t$ は、\n",
"\n",
"$$\n",
"t\\approx \\frac{\\pi}{4} \\sqrt{\\frac{N}{|A_1|}}-\\frac{1}{2}\n",
"$$\n",
"\n",
"ここで、 $|A_1|$ は解の状態の数であり、 $N=2^n$ は状態の総数である。 現代のノイズの多い量子コンピュータでは、実験的に最適な反復回数は異なる可能性があるが、ここでは $|A_1|=1$ を用いて、この理論上の最適値を算出し、それを用いる。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d07c701a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"optimal_num_iterations = math.floor(\n",
" math.pi / (4 * math.asin(math.sqrt(len(marked_states) / 2**grover_op.num_qubits)))\n",
")\n",
"print(optimal_num_iterations)"
]
},
{
"cell_type": "markdown",
"id": "4698589c",
"metadata": {},
"source": [
"ここで、すべての可能な状態の重ね合わせを作るために、最初のハダマードゲートを含む回路を構成し、グローバー演算子を最適な回数適用してみよう。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "63006e25",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(grover_op.num_qubits)\n",
"# Create even superposition of all basis states\n",
"qc.h(range(grover_op.num_qubits))\n",
"# Apply Grover operator the optimal number of times\n",
"qc.compose(grover_op.power(optimal_num_iterations), inplace=True)\n",
"# Measure all qubits\n",
"qc.measure_all()\n",
"qc.draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "f14e6ebd",
"metadata": {},
"source": [
"グローバー・サーキットを構築した！\n",
"\n",
"\n",
"\n",
"### ステップ2：量子ハードウェア実行に向けた問題の最適化\n",
"\n",
"抽象的な量子回路は定義できたが、実際に使いたい量子コンピュータに固有のゲートで書き直す必要がある。 また、量子コンピュータのどの量子ビットを使うかも指定する必要がある。 これらの理由も含めて、我々は今、回路をトランスパイルしなければならない。 まず、使用する量子コンピュータを指定しよう。\n",
"\n",
"初回使用時に認証情報を保存するためのコードが以下にあります。 ノートブックを自分の環境に保存した後、必ずこの情報をノートブックから削除してください。そうすれば、ノートブックを共有するときにあなたの認証情報が誤って共有されることはありません。 詳しいガイダンスについては、 [IBM Cloud アカウントの設定](/docs/guides/initialize-account)および[信頼できない環境でのサービスの初期](/docs/guides/cloud-setup-untrusted)化を参照してください。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "994ef054",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"qiskit_runtime_service._resolve_cloud_instances:WARNING:2025-08-08 14:14:19,931: Default instance not set. Searching all available instances.\n"
]
},
{
"data": {
"text/plain": [
"'ibm_brisbane'"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# To run on hardware, select the backend with the fewest number of jobs in the queue\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"\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",
"backend = service.least_busy(operational=True, simulator=False)\n",
"backend.name"
]
},
{
"cell_type": "markdown",
"id": "a65cf945",
"metadata": {},
"source": [
"ここで、プリセット・パス・マネージャーを使って、選択したバックエンドに量子回路を最適化する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 171,
"id": "35fbd6ef",
"metadata": {},
"outputs": [],
"source": [
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"circuit_isa = pm.run(qc)\n",
"# The transpiled circuit will be very large. Only draw it if you are really curious.\n",
"# circuit_isa.draw(output=\"mpl\", idle_wires=False, style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "014b7868",
"metadata": {},
"source": [
"この際、トランスパイルされた量子回路の深さが相当なものであることは注目に値する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 172,
"id": "d168576f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The total depth is 439\n",
"The depth of two-qubit gates is 113\n"
]
}
],
"source": [
"print(\"The total depth is \", circuit_isa.depth())\n",
"print(\n",
" \"The depth of two-qubit gates is \",\n",
" circuit_isa.depth(lambda instruction: instruction.operation.num_qubits == 2),\n",
")"
]
},
{
"cell_type": "markdown",
"id": "aaea2d8d",
"metadata": {},
"source": [
"この単純なケースでも、実際にはかなり大きな数字である。 すべての量子ゲート（特に2量子ビットゲート）には誤差が生じ、ノイズの影響を受けるため、量子ビットが極めて高性能でなければ、100個以上の2量子ビットゲートを連ねてもノイズにしかならない。 これらのパフォーマンスを見てみよう。\n",
"\n",
"\n",
"\n",
"### ステップ 3: `IBM Quantum` プリミティブを使用して実行する\n",
"\n",
"多くの測定を行い、どの状態が最も可能性が高いかを確認したいと考えています。 このような振幅の増幅は、 IBM Quantum プリミティブでの実行に適したサンプリングの問題です `Sampler` 。\n",
"\n",
"なお、 IBM QuantumSamplerV2 のメソッド `run()` は、プリミティブ統一ブロック（PUB）の反復可能オブジェクトを受け取ることに注意してください。 Sampler では、各 `PUB` は (circuit, parameter\\_values) という形式の反復可能オブジェクトです。 とはいえ、少なくとも量子回路のリストは必要となります。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2a272d9e",
"metadata": {},
"outputs": [],
"source": [
"# To run on a real quantum computer (this was tested on a Heron r2 processor and\n",
"# used 4 sec. of QPU time)\n",
"\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"sampler.options.default_shots = 10_000\n",
"result = sampler.run([circuit_isa]).result()\n",
"dist = result[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "7a123100",
"metadata": {},
"source": [
"この経験を最大限に活用するには、 IBM Quantumから入手可能な本物の量子コンピューターで実験を行うことを強くお勧めする。 しかし、QPUの時間を使い果たした場合は、以下の行のコメントを外して、シミュレーターを使ってこのアクティビティを完了することができます。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e60bcbec",
"metadata": {},
"outputs": [],
"source": [
"# To run on local simulator:\n",
"# from qiskit.primitives import StatevectorSampler as Sampler\n",
"# sampler = Sampler()\n",
"# result = sampler.run([qc]).result()\n",
"# dist = result[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "f19b1adb",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ4：後処理を行い、結果を希望の古典形式で返す\n",
"\n",
"これでサンプリングの結果をヒストグラムにプロットできる。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 97,
"id": "96a9107e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 97,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot_distribution(dist)"
]
},
{
"cell_type": "markdown",
"id": "9dabb017",
"metadata": {},
"source": [
"グローバーのアルゴリズムは、他の選択肢よりも少なくとも一桁高い確率で、望みの状態を返したことがわかる。 次のアクティビティでは、クエリーアルゴリズムの2者間ワークフローにより合致した方法でアルゴリズムを使用する。\n",
"\n",
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"私たちはただ、 $2^4=16$ の可能な状態の集合の中から、ひとつの解を探しただけなのだ。 我々はグローバー演算子の最適繰り返し回数を $t=3$ と決定した。もし(a)複数の解のいずれかを探索した場合、あるいは(b)より多くの可能な状態の空間における単一の解を探索した場合、この最適数は増減しただろうか？\n",
"\n",
"\n",
" \n",
" 解の数が解の空間全体に比べて少ない限り、正弦関数を小さな角度の周りに展開して、次のように使うことができる\n",
"\n",
" $$\n",
" (2t+1)\\theta = (2t+1) \\sin^{-1}{\\sqrt{\\frac{|\\mathcal{A}_1|}{N}}}\\approx (2t+1) \\sqrt{\\frac{|\\mathcal{A}_1|}{N}} \\approx \\pi/2\\\\\n",
"\n",
" t \\approx \\frac{\\pi}{4}\\sqrt{\\frac{N}{|\\mathcal{A}_1|}}-\\frac{1}{2}\n",
" $$\n",
"\n",
" (a)上の式から、解の状態数を増やすと反復回数が減ることがわかる。 $\\frac{|\\mathcal{A}_1|}{N}$ の割合がまだ小さければ、 $t$ がどのように減少するかを説明することができる： $t~\\frac{1}{\\sqrt{|\\mathcal{A}_1|}}.$\n",
"\n",
" (b) 可能解の空間( $N$ )が増加するにつれて、必要な反復回数は増加するが、 $t~\\sqrt{N}$ のようにしか増加しない。\n",
" \n",
"\n",
"\n",
"ターゲットのビット列のサイズを任意に長くしても、ターゲットの状態が他のどの状態よりも少なくとも1桁大きい確率振幅を持つという結果が得られるとしよう。 グルーバーのアルゴリズムを使えば、確実に目標状態を見つけられるということですか？\n",
"\n",
"\n",
" \n",
" いいえ 最初の活動を20量子ビットで繰り返し、量子回路を `num_shots = 10,000` 回実行したとする。 一様な確率分布とは、すべての状態が一度でも測定される確率が $10,000/2^{20}=0.00954$。 仮に、目標状態を測定する確率が、非解答の確率の10倍であったとすると（それに応じて、各非解答の確率もわずかに減少する）、目標状態を1回でも測定できる確率は10％程度しかない。 目標状態を何度も測定することはまず不可能であり、その結果、ランダムに得られる多くの非解決状態と区別がつかなくなる。 良いニュースは、エラー抑制と緩和を使えば、さらに忠実度の高い結果を得られるということだ。\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"## アクティビティ2：正確なクエリアルゴリズムのワークフロー\n",
"\n",
"このアクティビティも最初のアクティビティとまったく同じように始めますが、もう一人のQiskit愛好家とペアを組むことになります。 あなたは秘密のビット列を選び、パートナーは（一般的に）異なるビット列を選ぶ。 それぞれオラクルとして機能する量子回路を生成し、それを交換する。 その後、あなたはそのオラクルを使ってグローバーのアルゴリズムを使い、パートナーの秘密のビット列を決定する。\n",
"\n",
"\n",
"\n",
"### ステップ1：古典的な入力を量子問題にマッピングする\n",
"\n",
"上で定義した `grover_oracle` 関数を使って、1つ以上のマークされた状態に対するオラクル回路を構築する。 パートナーがグローバー・オペレーターを最適な回数適用できるように、マークした州の数を必ずパートナーに伝えること。 **ビット文字列を長くしすぎないこと。 3-5ビットはそれほど問題なく使えるはずだ。** ビット列が長くなれば、エラー緩和などのより高度な技術を必要とする深い回路になる。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 173,
"id": "5be9092e",
"metadata": {},
"outputs": [],
"source": [
"# Modify the marked states to mark those you wish to target.\n",
"marked_states = [\"1000\"]\n",
"oracle = grover_oracle(marked_states)"
]
},
{
"cell_type": "markdown",
"id": "b4874b93",
"metadata": {},
"source": [
"これで、目標の状態の位相を反転させる量子回路ができた。 この回路は、以下の構文を使って `my_circuit.qpy` として保存することができる。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "77093258",
"metadata": {},
"outputs": [],
"source": [
"from qiskit import qpy\n",
"\n",
"# Save to a QPY file at a location where you can easily find it.\n",
"# You might want to specify a global address.\n",
"with open(\"C:\\\\Users\\\\...put your own address here...\\\\my_circuit.qpy\", \"wb\") as f:\n",
" qpy.dump(oracle, f)"
]
},
{
"cell_type": "markdown",
"id": "524f5577",
"metadata": {},
"source": [
"このファイルをパートナーに送る（電子メール、メッセージングサービス、共有レポなどを介して）。 パートナーにもサーキットを送ってもらう。 ファイルは必ず、簡単に見つけられる場所に保存してください。 パートナーの回路を手に入れたら、それを視覚化することができる。 つまり、オラクルに問い合わせる（オラクル回路を使用する）ことはできるが、オラクルがどのような状態を対象としているかを調べることはできないという状況をモデル化しているのだ。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "24ba4869",
"metadata": {},
"outputs": [],
"source": [
"from qiskit import qpy\n",
"\n",
"# Load the circuit from your partner's qpy file from the folder where you saved it.\n",
"with open(\"C:\\\\Users\\\\...file location here...\\\\my_circuit.qpy\", \"rb\") as f:\n",
" circuits = qpy.load(f)\n",
"\n",
"# qpy.load always returns a list of circuits\n",
"oracle_partner = circuits[0]\n",
"\n",
"# You could visualize the circuit, but this would break the model of a query algorithm.\n",
"# oracle_partner.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "0c7b7012",
"metadata": {},
"source": [
"パートナーに何個のターゲット状態をエンコードしたか尋ね、それを以下に記入する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 174,
"id": "120e339c",
"metadata": {},
"outputs": [],
"source": [
"# Update according to your partner's number of target states.\n",
"num_marked_states = 1"
]
},
{
"cell_type": "markdown",
"id": "f2c4b911",
"metadata": {},
"source": [
"これは次の式で使用され、最適なグローバーの反復回数を決定する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 175,
"id": "d199a8cc",
"metadata": {},
"outputs": [],
"source": [
"grover_op = grover_operator(oracle_partner)\n",
"optimal_num_iterations = math.floor(\n",
" math.pi / (4 * math.asin(math.sqrt(num_marked_states / 2**grover_op.num_qubits)))\n",
")\n",
"qc = QuantumCircuit(grover_op.num_qubits)\n",
"qc.h(range(grover_op.num_qubits))\n",
"qc.compose(grover_op.power(optimal_num_iterations), inplace=True)\n",
"qc.measure_all()"
]
},
{
"cell_type": "markdown",
"id": "37eb709b",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ2：量子ハードウェア実行に向けた問題の最適化\n",
"\n",
"これは以前とまったく同じように進行する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 176,
"id": "e5e89707",
"metadata": {},
"outputs": [],
"source": [
"# To run on hardware, select the backend with the fewest number of jobs in the queue\n",
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(operational=True, simulator=False)\n",
"backend.name\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"circuit_partner_isa = pm.run(qc)"
]
},
{
"cell_type": "markdown",
"id": "de2af3e1",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ 3: `IBM Quantum` プリミティブを使用して実行する\n",
"\n",
"これも最初の活動でのプロセスと同じである。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "16f97083",
"metadata": {},
"outputs": [],
"source": [
"# To run on a real quantum computer (this was tested on a Heron r2 processor and used\n",
"# 4 seconds of QPU time)\n",
"\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"sampler.options.default_shots = 10_000\n",
"result = sampler.run([circuit_partner_isa]).result()\n",
"dist = result[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "14bbde32",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ4：後処理を行い、結果を希望の古典形式で返す\n",
"\n",
"サンプリング結果のヒストグラムを表示します。 1つまたは複数の状態が、他の状態よりもはるかに高い測定確率を持つはずである。 これらの結果をパートナーに報告し、目標状態を正しく決定できたかどうかをチェックする。 デフォルトでは、表示されるヒストグラムは、最初のアクティビティと同じ回路のものです。 パートナーのサーキットとは異なる結果が得られるはずだ。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 114,
"id": "ee7a59ac",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot_distribution(dist)"
]
},
{
"cell_type": "markdown",
"id": "9c03a936",
"metadata": {},
"source": [
"\n",
"\n",
"#### 理解度チェック\n",
"\n",
"あなたはパートナーの目標状態を正しく取得しているはずです。 そうでなかった場合は、何がいけなかったのかをパートナーと一緒に考えてください。 いくつかのアイデアは下記をクリック。\n",
"\n",
"\n",
" \n",
" * パートナーの回路を視覚化/描画し、正しくロードされていることを確認する。\n",
" * 使用した回路を比較し、期待された結果と得られた結果を比較する。\n",
" * ビット列が長すぎたり、グローバーの反復回数が法外に多かったりしないように、使用する回路の深さをチェックする。\n",
" \n",
"\n",
"\n",
"まだの人は、パートナーから送られてきたオラクル回路を描く。 各ゲートの効果を説明し、目標状態がどうであったに違いないかを論じることができるかどうか。 マークされた状態が1つの場合は、複数の場合よりもずっと簡単だろう。\n",
"\n",
"\n",
" \n",
" * オラクルの仕事は、ターゲット状態の符号を反転させることであることを思い出してほしい。\n",
" * MCMTGateが状態の符号を反転させるのは、制御に関わるすべての量子ビットが $|1\\rangle$。\n",
" * もしターゲットとする状態がすでに特定の量子ビットに $|1\\rangle$、その量子ビットには何もする必要はない。 ターゲットが特定の量子ビットに $|0\\rangle$、MCMTGateで符号を反転させたい場合は、オラクルでその量子ビットに `X` ゲートを適用する必要がある（そしてMCMTGateの後に `X` ゲートを元に戻す）。\n",
" \n",
"\n",
"\n",
"グローバー演算子の反復回数を1回減らして実験を繰り返す。 それでも正解は出ますか？ その理由は何か?\n",
"\n",
"\n",
" \n",
" エンコードされた解の数にもよるだろうが、おそらくそうなるだろう。 これは微妙な点を浮き彫りにしている。「最適な」グローバーの反復回数は、マークされた状態を測定する確率を可能な限り高くする回数である。 しかし、それよりも少ない反復回数でも、マークされた状態が他の状態よりもかなり可能性が高くなるかもしれない。 したがって、最適な反復回数よりも少ない回数で済むかもしれない。 これによって回路の深さが浅くなり、エラー率が低下する。\n",
" \n",
"\n",
"\n",
"グローバーの反復回数を「最適な回数」よりも少なくしたい人がいるのはなぜか？\n",
"\n",
"\n",
" \n",
" 最適な」グローバーの反復回数は、ノイズがない場合に、マークされた状態を測定する確率を可能な限り高くする回数である。 しかし、それよりも少ない反復回数でも、マークされた状態が他の状態よりもかなり可能性が高くなるかもしれない。 そのため、最適な反復回数よりも少ない回数で済むかもしれない。 これによって回路の深さが浅くなり、エラー率が低下する。\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "mine_intro_01",
"metadata": {},
"source": [
"\n",
"\n",
"## アクティビティ3：グローバーのアルゴリズムを使ってマインスイーパのグリッドを解く\n",
"\n",
"前の節で述べたように、グローバーのアルゴリズムが真に有用となるのは、答えの知識からではなく、問題の*制約*条件からオラクルを構築できる場合である。 「マインスイーパ」はその好例です。番号の付いたマス目は、隣接する地雷の数を示しており、これらの制約条件によって地雷の位置は完全に決定されますが、その配置を見つけるには探索が必要です。\n",
"\n",
"マインスイーパはNP完全であることが証明されている。つまり、解くのは難しいが、正解かどうかを確認するのは簡単である。 したがって、これはグローバーのアルゴリズムの自然な適用対象となる。 もちろん、ノイズの多い量子コンピュータでは、まだ9× $\\times$ 9のグリッド全体を解くことはできません。回路があまりにも深くなってしまうからです。 その代わりに、将来の耐障害性マシン上でより大きなボードをどのように扱うかについて、簡単な実例として小さなグリッドを使用します。\n",
"\n",
"いくつか重要な注意点があります。 グローバーのアルゴリズムは\\*、構造を持たない\\*従来の探索に比べて、計算速度を2倍に高速化するに過ぎない。 「マインスイーパ」には、巧妙な古典的アルゴリズムが活用できるような構造が、ほぼ間違いなく存在している。 そして、指数関数的に拡大する探索空間においては、 $\\sqrt{N}$ による改善効果にも限界がある。 しかし、そうした懸念はひとまず脇に置いて、この単純な問題を例に、問題の制約条件が量子オラクルにどのようにエンコードされるかを説明しましょう。\n",
"\n",
"\n",
"\n",
"### グリッド\n",
"\n",
"こちらが、私たちの「ベビー・マインスイーパー」の盤面です：\n",
"\n",
"\n",
"\n",
"各空のセルは、そこに地雷があるかどうかを示す二値変数で表すことができます。 これらを $x_0$、 $x_1$、 $x_2$ と表記する。ここで、 $x_i = 1$ はそのセルに地雷があることを意味し、 $x_i = 0$ は地雷がないことを意味する：\n",
"\n",
"\n",
"\n",
"頭の中でなら0.5秒ほどで解ける問題ですが、この単純な例題を用いて、量子コンピュータを使えば、はるかに難しい問題にどのように取り組むことができるかを説明しています。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "mine_bool_01",
"metadata": {},
"source": [
"\n",
"\n",
"### 制約をエンコードする\n",
"\n",
"番号が振られた各セルは、隣接する空白のセルに対して条件を課します。 これらの条件を、量子回路として表現できるブール式として表す必要があります。\n",
"\n",
"$x_0$ と $x_1$ に隣接する「1」のセルは、この2つのうちちょうど1つに地雷が仕掛けられていることを示しています。 これはまさに排他的論理和（XOR）演算、 $\\oplus$ であり、入力のうちちょうど1つが真である場合に真を返します：\n",
"\n",
"$$\n",
"(x_0 \\oplus x_1)\n",
"$$\n",
"\n",
"同様に、もう1つの「1」のセル（ $x_1$ および $x_2$ に隣接するセル）からは、以下の結果が得られます：\n",
"\n",
"$$\n",
"(x_1 \\oplus x_2)\n",
"$$\n",
"\n",
"「2」と書かれたマスには、3つの空白マスのうち2つに地雷が埋まっていることが示されています。 XORはパリティ演算であるため、変数の真の数が*奇数*の場合、 $x_0 \\oplus x_1 \\oplus x_2$ はtrueを返します。 *偶*数（具体的には2）が真となるようにしたいので、 $\\lnot$ を用いて否定します：\n",
"\n",
"$$\n",
"\\lnot(x_0 \\oplus x_1 \\oplus x_2)\n",
"$$\n",
"\n",
"この式は、パリティに関する記述であるため、 $|1\\rangle$ 状態にあるクビットが0個か2個のいずれかであれば、その条件を満たすことになる。 しかし、それぞれ少なくとも1つの地雷を配置する必要がある他の2つの条件と組み合わせると、条件を満たす唯一の解は、地雷がちょうど2つ配置されたものとなる。\n",
"\n",
"これら3つの条件はすべて同時に満たされる必要があるため、and記号を用いてこれらを結合します。 $\\land$ ：\n",
"\n",
"$$\n",
"(x_0 \\oplus x_1) \\;\\land\\; (x_1 \\oplus x_2) \\;\\land\\; \\lnot(x_0 \\oplus x_1 \\oplus x_2)\n",
"$$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "mine_oracle_01",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ1：古典的な入力を量子問題にマッピングする\n",
"\n",
"次に、このブール式を、オラクルとして機能する量子回路にエンコードする必要があります。 量子版XORは、CX（CNOT）ゲートを用いて実現できる。データ量子ビットからワークスペース（アンシラ）量子ビットに対して2つのCXゲートを適用することで、事実上それらのXOR演算を行い、その結果をアンシラに保存する。\n",
"\n",
"各節に1つずつ、計3つのワークスペース量子ビットを導入する。 各ブール式の結果を対応するワークスペース量子ビットに格納し、その後、マルチ制御Zゲートを使用して3量子ビット状態の位相を反転させ、3つのワークスペース量子ビットすべてを $|1\\rangle$ （つまり、すべての節が同時に満たされる）の状態にする。\n",
"\n",
"以下の最初のコードセルでは、オラクルの「演算」部分、つまり各節を評価し、その結果をワークスペースの量子ビットに書き込む部分を構築します。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_oracle1",
"metadata": {},
"outputs": [],
"source": [
"x = QuantumRegister(3, \"x\")\n",
"a = QuantumRegister(3, \"a\")\n",
"qc = QuantumCircuit(x, a)\n",
"\n",
"# Clause 1: x0 XOR x1 -> stored in a[0]\n",
"qc.cx(x[0], a[0])\n",
"qc.cx(x[1], a[0])\n",
"\n",
"# Clause 2: x1 XOR x2 -> stored in a[1]\n",
"qc.cx(x[1], a[1])\n",
"qc.cx(x[2], a[1])\n",
"\n",
"# Clause 3: NOT(x0 XOR x1 XOR x2) -> stored in a[2]\n",
"qc.cx(x[0], a[2])\n",
"qc.cx(x[1], a[2])\n",
"qc.cx(x[2], a[2])\n",
"qc.x(a[2]) # The NOT\n",
"\n",
"qc.draw(\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "mine_mcz_01",
"metadata": {},
"source": [
"この時点で、各節の結果は、対応するワークスペース量子ビットに格納されます。 ここで、ワークスペースの3つの量子ビットすべてが $|1\\rangle$ となるような3量子ビットのデータ状態が必要であり、これによりマイナス符号が付与される。 これには、多重制御Zゲート（ターゲット側でハダマールゲートに挟まれたMCXゲートとして実装）を使用します。\n",
"\n",
"位相反転を適用した後、ワークスペースの量子ビットを $|0\\rangle.$ の状態に戻すために、逆順ですべての句評価ステップを元に戻す（ **アンコンピュート** ）必要があります。これは、Grover演算子のその後の反復処理において、ワークスペースの量子ビットがクリーンな状態にあるようにするために不可欠です。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_oracle2",
"metadata": {},
"outputs": [],
"source": [
"# Multi-controlled Z: flip phase if all workspace qubits are |1>\n",
"qc.h(a[2])\n",
"qc.mcx([a[0], a[1]], a[2])\n",
"qc.h(a[2])\n",
"\n",
"# Uncompute clause 3: NOT(x0 XOR x1 XOR x2)\n",
"qc.x(a[2])\n",
"qc.cx(x[2], a[2])\n",
"qc.cx(x[1], a[2])\n",
"qc.cx(x[0], a[2])\n",
"\n",
"# Uncompute clause 2: x1 XOR x2\n",
"qc.cx(x[2], a[1])\n",
"qc.cx(x[1], a[1])\n",
"\n",
"# Uncompute clause 1: x0 XOR x1\n",
"qc.cx(x[1], a[0])\n",
"qc.cx(x[0], a[0])\n",
"\n",
"qc.draw(\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "mine_groverop_01",
"metadata": {},
"source": [
"この回路は私たちの「オラクル」です。これは、マインスイーパの3つの制約すべてを満たすデータ量子ビットの状態の位相を反転させ、ワークスペース量子ビットの状態を元のままに保ちます。 $|0\\rangle.$\n",
"\n",
"ここで、このオラクルから完全なグローバー演算子を構築する。 `x`引数に `reflection_qubits` 注意してください：ワークスペース量子ビットは探索空間の一部ではないため、データ量子ビットのみを渡します。 オラクルが適用されれば、彼らの仕事は完了する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_groverop",
"metadata": {},
"outputs": [],
"source": [
"grover_op = grover_operator(qc, reflection_qubits=x)\n",
"grover_op.decompose(reps=0).draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "mine_circuit_01",
"metadata": {},
"source": [
"データ量子ビットが3つ、解の状態が1つある場合、Grover反復の最適回数は $t \\approx \\frac{\\pi}{4}\\sqrt{8} - \\frac{1}{2} \\approx 1.7$ となるため、ここでは2回の反復を行う。 データ量子ビットにアダマールゲートを適用して初期の重ね合わせ状態を作り出し、グローバー演算子を2回重ね合わせ、データ量子ビットのみを測定する。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_circuit",
"metadata": {},
"outputs": [],
"source": [
"x = QuantumRegister(3, \"x\")\n",
"a = QuantumRegister(4, \"a\")\n",
"meas = ClassicalRegister(3, \"meas\")\n",
"\n",
"qc = QuantumCircuit(x, a, meas)\n",
"# Create superposition over the data qubits only\n",
"qc.h(x)\n",
"# Apply 2 iterations of the Grover operator\n",
"qc.compose(grover_op.power(2), inplace=True)\n",
"# Measure only the data qubits\n",
"qc.measure(x, meas)\n",
"qc.decompose().draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "mine_step2_01",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ2：量子ハードウェア実行に向けた問題の最適化\n",
"\n",
"これまでと同様に、ターゲットバックエンド向けに回路をトランスパイルします。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_transpile",
"metadata": {},
"outputs": [],
"source": [
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(operational=True, simulator=False)\n",
"print(backend.name)\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"circuit_isa = pm.run(qc)"
]
},
{
"cell_type": "markdown",
"id": "mine_depth_01",
"metadata": {},
"source": [
"これで、トランスパイルされた回路の深さを確認できます。 マインスイーパ・オラクルはワークスペース量子ビットと複数のCXゲートを使用するため、トランスパイルされた回路は、これまでの演習で扱ったものよりも深くなります。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_depth",
"metadata": {},
"outputs": [],
"source": [
"print(\"The total depth is \", circuit_isa.depth())\n",
"print(\n",
" \"The depth of two-qubit gates is \",\n",
" circuit_isa.depth(lambda instruction: instruction.operation.num_qubits == 2),\n",
")"
]
},
{
"cell_type": "markdown",
"id": "mine_step3_01",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ 3: `IBM Quantum` プリミティブを使用して実行する\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_run",
"metadata": {},
"outputs": [],
"source": [
"# To run on a real quantum computer (this was tested on a Heron r2 processor and\n",
"# used 4 sec. of QPU time)\n",
"\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"sampler.options.default_shots = 10_000\n",
"result = sampler.run([circuit_isa]).result()\n",
"dist = result[0].data.meas.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_sim",
"metadata": {},
"outputs": [],
"source": [
"# To run on local simulator:\n",
"# from qiskit.primitives import StatevectorSampler as Sampler\n",
"# sampler = Sampler()\n",
"# result = sampler.run([qc]).result()\n",
"# dist = result[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "mine_step4_01",
"metadata": {},
"source": [
"\n",
"\n",
"### ステップ4：後処理を行い、結果を希望の古典形式で返す\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "mine_code_plot",
"metadata": {},
"outputs": [],
"source": [
"plot_distribution(dist)"
]
},
{
"cell_type": "markdown",
"id": "mine_conclusion_01",
"metadata": {},
"source": [
"この `101` 状態は他のどの状態よりもはるかに高い確率で現れるはずであり、これは地雷が $x_0$ および $x_2$ に配置されていることを示しています。私たちは量子コンピュータを使って、ミニマインスイーパを解いたのです！\n",
"\n",
"もちろん、マインスイーパにおける最良の古典的アルゴリズムは、すべての地雷配置を網羅的に探索する力業的な手法よりも優れています。それらはグリッドの構造を巧みに利用しているからです。 グローバーのアルゴリズムが優位性を発揮するのは、最大限に曖昧になるよう設計された極めて困難なボードに限られる。たとえそのような場合でも、その速度向上は二次関数的なものに過ぎないため、指数関数的な増加にいつまでも追いつき続けることはできない。 しかし、真に重要なのはその手法そのものです。問題の制約を量子オラクルにエンコードするという手法は、制約充足問題や組み合わせ最適化、その他多くの分野に応用できる強力なパターンなのです。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "494c1799",
"metadata": {},
"source": [
"\n",
"\n",
"## 質問と重要な概念：\n",
"\n",
"\n",
"\n",
"### 重要な概念：\n",
"\n",
"このモジュールでは、グローバーのアルゴリズムの主な特徴を学んだ：\n",
"\n",
"* 古典的な非構造化検索アルゴリズムが、空間の大きさに対して線形にスケールするクエリー数を必要とするのに対し、 $N,$ Groverのアルゴリズムは、次のようにスケールするクエリー数を必要とする。 $\\sqrt{N}.$\n",
"* グローバーのアルゴリズムでは、一連の操作（一般に「グローバー演算子」と呼ばれる）を、目標状態が測定される可能性が最適になるように選択された回数（ $t,$ ）繰り返す。\n",
"* Groverのアルゴリズムは、 $t$ より少ない反復回数で実行しても、目標状態を増幅することができる。\n",
"* グローバーのアルゴリズムは計算のクエリーモデルに適合し、一人が検索を制御し、もう一人がオラクルを制御／構築する場合に最も理にかなっている。 また、他の量子計算のサブルーチンとしても有用だろう。\n",
"* 「マインスイーパ」の例で示されたように、オラクルは解に関する知識ではなく、 *問題の制約条件*から構築することができる。\n",
"\n",
"\n",
"\n",
"### 正誤問題：\n",
"\n",
"1. T/F グローバーのアルゴリズムは、構造化されていない検索において、一つのマークされた状態を見つけるのに必要なクエリーの数において、古典的なアルゴリズムよりも指数関数的な改善をもたらす。\n",
"\n",
"2. T/F グローバーのアルゴリズムは、解の状態が測定される確率を反復的に増加させることによって機能する。\n",
"\n",
"3. T/F グローバー演算子を何度も繰り返すほど、解の状態を測定する確率が高くなる。\n",
"\n",
"\n",
"\n",
"### MCの質問：\n",
"\n",
"1. 文を完成させるのに最も適した選択肢を選びなさい。 最新の量子コンピューターでグローバーのアルゴリズムを成功させる最善の方法は、グローバー演算子を反復することである...\n",
"\n",
"* a. 一度だけだ。\n",
"* b. 常に $t$、解の状態の確率振幅を最大にする。\n",
"* c. 最大で $t$、解決策を際立たせるには少ない回数で十分かもしれない。\n",
"* d. 10回以上だ。\n",
"\n",
"2. ここでは、ある状態を位相反転でマークするオラクルとして機能する位相問い合わせ回路を示す。 この回路によってマークされる状態は次のうちどれか？\n",
"\n",
"\n",
"\n",
"* a. $|0000\\rangle$\n",
"* b. $|0101\\rangle$\n",
"* c. $|0110\\rangle$\n",
"* d. $|1001\\rangle$\n",
"* e. $|1010\\rangle$\n",
"* f. $|1111\\rangle$\n",
"\n",
"3. 128のセットから3つのマークされた状態を検索したいとする。 マークされた状態の振幅を最大化するためのグローバー演算子の最適な反復回数は？\n",
"\n",
"* a. 1\n",
"* b. 3\n",
"* c. 5\n",
"* d. 6\n",
"* e. 20\n",
"* f. 33\n",
"\n",
"\n",
"\n",
"### ディスカッションの質問：\n",
"\n",
"1. 他にどのような問題をグローバー探索として定式化できるでしょうか？ 解決策を見つけるのは難しいけれど、その正しさを確認するのは簡単な問題を思い浮かべてみてください。\n",
"\n",
"2. グローバーのアルゴリズムを現代の量子コンピューターでスケーリングすることに問題はないのか？\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"
}
},
"nbformat": 4,
"nbformat_minor": 5
}