{
"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",
"ここでは、Groverのオラクルを構築し、Qiskit回路ライブラリの `GroverOperator` 、Groverの探索インスタンスを簡単にセットアップする方法を示す。 ランタイム `Sampler` プリミティブは、グローバー回路のシームレスな実行を可能にする。\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",
"下の問題を読んで答えを考え、三角形をクリックして解答を表示させましょう。\n",
"\n",
"\n",
" \n",
" ハダマードゲートの定義から出発して、ハダマードゲートの2回目の適用が、上記のような重ね合わせを元に戻すことを示す。\n",
"
\n",
"\n",
" **回答:**\n",
"\n",
" Xを $|+\\rangle$ の状態に適用すると、値と+1が得られ、 $|-\\rangle$ の状態に適用すると、 -1 が得られる。したがって、分布が半々であれば、期待値は0となる。\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": "3fd8fbb3",
"metadata": {},
"source": [
"\n",
"\n",
"## 明らかな注意点\n",
"\n",
"グローバーのアルゴリズムを適用するためには、グローバー演算子を構築しなければならない。つまり、解の基準を満たす状態で位相を反転させることができなければならない。 もし私たちが解の集合をよく知っていて、それぞれにラベルを付ける量子回路を設計できるのなら、私たちは何を探しているのだろうか？ その答えは3つあり、チュートリアルの中で再確認することになる：\n",
"\n",
"**（1）この種のクエリアルゴリズムには、多くの場合、解決基準を確立するオラクルを持っている人と、解決状態を推測/見つけようとしている人の2つの当事者が関与します**。 一人でオラクルを作ることができるという事実は、サーチの必要性を否定するものではない。\n",
"\n",
"**(2)解を見つけるよりも解の基準を指定する方が簡単な問題がある。** 最もよく知られている例は、大きな数の素因数を特定することだろう。 グルーバーのアルゴリズムは、この特定の問題を解くのに特に有効ではない。 これは、ある状態の振る舞いの基準を知ることが、必ずしもその状態を知ることと同じではないことを指摘するための一例に過ぎない。\n",
"\n",
"**(3) グローバーのアルゴリズムは古典的なデータだけを返すわけではない。** 確かに、 $t$ グルーバー演算子を繰り返した後の最終状態を測定すれば、解の状態を特定する古典的な情報が得られる可能性が高い。 しかし、古典的な情報ではなく、別のアルゴリズムで使用するために量子コンピューター上で準備された解の状態が必要だとしたらどうだろう？ グルーバーのアルゴリズムは、実際には解に重みを持たせた量子状態を生成する。 そのため、より複雑な量子アルゴリズムのサブルーチンとして、グローバーのアルゴリズムを見つけることができるかもしれない。\n",
"\n",
"これらを念頭に置いて、いくつかの例を見てみよう。 解の状態が明確に指定され、アルゴリズムの論理を追うことができる例から始め、グローバーのアルゴリズムの有用性がより明確になる例へと進む。\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\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: Qiskit Runtime プリミティブを使った実行\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",
"(2t+1)\\theta = (2t+1)\\sin^{-1}\\left( \\sqrt{\\frac{|A_1|}{N}}\\right) \\approx (2t+1)\\sqrt{\\frac{|A_1|}{N}} \\approx \\frac{\\pi}{2}\\\\\n",
"t\\approx \\frac{\\pi}{4} \\sqrt{\\frac{N}{|A_1|}}-\\frac{1}{2}\n",
"$$\n",
"\n",
"ここで、 $A_1$ は、解または目標状態の数である。 現代のノイズの多い量子コンピュータでは、実験的に最適な反復回数は異なるかもしれませんが、ここでは $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",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', 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",
"## Qiskit primitives を使用して実行する\n",
"\n",
"多くの測定を行い、どの状態が最も可能性が高いかを確認したい。 このような振幅増幅は、 `Sampler` Qiskit Runtime プリミティブでの実行に適したサンプリング問題である。\n",
"\n",
"Qiskit Runtime SamplerV2 の `run()` メソッドは、プリミティブ・ユニファイド・ブロック（PUB）の反復可能性を取ることに注意。 Samplerの場合、 PUB は、(circuit, parameter\\_values)というフォーマットで反復可能である。 しかし、最低限、量子回路のリストは必要だ。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 96,
"id": "2a272d9e",
"metadata": {},
"outputs": [],
"source": [
"# To run on a real quantum computer (this was tested on a Heron r2 processor and 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",
"下の問題を読んで答えを考え、三角形をクリックすると解答が現れます。\n",
"\n",
"\n",
" \n",
" 私たちはただ、 $2^4=16$ の可能な状態の集合の中から、ひとつの解を探しただけなのだ。 我々はグローバー演算子の最適繰り返し回数を $t=3$ と決定した。もし(a)複数の解のいずれかを探索した場合、あるいは(b)より多くの可能な状態の空間における単一の解を探索した場合、この最適数は増減しただろうか？\n",
"
\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",
" \n",
" ターゲットのビット列のサイズを任意に長くしても、ターゲットの状態が他のどの状態よりも少なくとも1桁大きい確率振幅を持つという結果が得られるとしよう。 グルーバーのアルゴリズムを使えば、確実に目標状態を見つけられるということですか？\n",
"
\n",
"\n",
" **回答:**\n",
"\n",
" いいえ 最初の活動を20量子ビットで繰り返し、量子回路を `num_shots = 10,000` 回実行したとする。 一様な確率分布とは、すべての状態が一度でも測定される確率が $10,000/2^{20}=0.00954$。 仮に、目標状態を測定する確率が、非解答の確率の10倍であったとすると（それに応じて、各非解答の確率もわずかに減少する）、目標状態を1回でも測定できる確率は10％程度しかない。 目標状態を何度も測定することはまず不可能であり、その結果、ランダムに得られる多くの非解決状態と区別がつかなくなる。 良いニュースは、エラー抑制と緩和を使えば、さらに忠実度の高い結果を得られるということだ。\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: `Qiskit primitives`を使用して実行する\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 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",
" * 使用した回路を比較し、期待された結果と得られた結果を比較する。\n",
" * ビット列が長すぎたり、グローバーの反復回数が法外に多かったりしないように、使用する回路の深さをチェックする。\n",
" \n",
"\n",
"\n",
" \n",
" まだの人は、パートナーから送られてきたオラクル回路を描く。 各ゲートの効果を説明し、目標状態がどうであったに違いないかを論じることができるかどうか。 マークされた状態が1つの場合は、複数の場合よりもずっと簡単だろう。\n",
"
\n",
"\n",
" **ヒント:**\n",
"\n",
" * オラクルの仕事は、ターゲット状態の符号を反転させることであることを思い出してほしい。\n",
" * MCMTGateが状態の符号を反転させるのは、制御に関わるすべての量子ビットが $|1\\rangle$。\n",
" * もしターゲットとする状態がすでに特定の量子ビットに $|1\\rangle$、その量子ビットには何もする必要はない。 ターゲットが特定の量子ビットに $|0\\rangle$、MCMTGateで符号を反転させたい場合は、オラクルでその量子ビットに `X` ゲートを適用する必要がある（そしてMCMTGateの後に `X` ゲートを元に戻す）。\n",
" \n",
"\n",
"\n",
" \n",
" グローバー演算子の反復回数を1回減らして実験を繰り返す。 それでも正解は出ますか？ その理由は何か?\n",
"
\n",
"\n",
" **ガイダンス**\n",
"\n",
" エンコードされた解の数にもよるだろうが、おそらくそうなるだろう。 これは微妙な点を浮き彫りにしている。「最適な」グローバーの反復回数は、マークされた状態を測定する確率を可能な限り高くする回数である。 しかし、それよりも少ない反復回数でも、マークされた状態が他の状態よりもかなり可能性が高くなるかもしれない。 したがって、最適な反復回数よりも少ない回数で済むかもしれない。 これによって回路の深さが浅くなり、エラー率が低下する。\n",
" \n",
"\n",
"\n",
" \n",
" グローバーの反復回数を「最適な回数」よりも少なくしたい人がいるのはなぜか？\n",
"
\n",
"\n",
" **回答:**\n",
"\n",
" 最適な」グローバーの反復回数は、ノイズがない場合に、マークされた状態を測定する確率を可能な限り高くする回数である。 しかし、それよりも少ない反復回数でも、マークされた状態が他の状態よりもかなり可能性が高くなるかもしれない。 そのため、最適な反復回数よりも少ない回数で済むかもしれない。 これによって回路の深さが浅くなり、エラー率が低下する。\n",
" \n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8c85ebd9",
"metadata": {},
"source": [
"\n",
"\n",
"## アクティビティ3：特定のビット列以外の基準\n",
"\n",
"グローバーのアルゴリズムがサブルーチンの文脈でどのように役立つかを示す最後の例として、ビット列表現で `1`sの数を持つ量子状態が必要だと想像してみよう。 これは保存則が関係する状況ではよくあることだ。 例えば、量子化学の文脈では、量子ビットの状態（ `1` ）を電子軌道の占有状態にマッピングすることがよくある。 電荷が保存されるためには、 `1`sの総数も一定でなければならない。 このような制約は非常に一般的であるため、 **ハミング重み制約という**特別な名前がついており、状態の `1`sの数を**ハミング重みと**呼ぶ。\n",
"\n",
"\n",
"\n",
"## ステップ 1:\n",
"\n",
"まず、状態を望ましいハミング重みでマークする関数を書いてみよう。 不特定多数の量子ビット（ `num_qubits` ）と目標ハミング重み（ `target_weight` ）について、一般的にこう書くことにする。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a3bb0650",
"metadata": {},
"outputs": [],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"\n",
"def grover_oracle_hamming_weight(num_qubits, target_weight):\n",
" \"\"\"\n",
" Build a Grover oracle that marks all states with Hamming weight == target_weight.\n",
"\n",
" Parameters:\n",
" num_qubits (int): Number of qubits in the circuit.\n",
" target_weight (int): The Hamming weight to mark.\n",
"\n",
" Returns:\n",
" QuantumCircuit: Quantum circuit representing Grover oracle.\n",
" \"\"\"\n",
" qc = QuantumCircuit(num_qubits)\n",
" marked_count = 0\n",
" marked_list = []\n",
" for x in range(2**num_qubits):\n",
" bitstr = format(x, f\"0{num_qubits}b\")\n",
" if bitstr.count(\"1\") == target_weight:\n",
" # Count the number of target states\n",
" marked_count = marked_count + 1\n",
" marked_list.append(bitstr)\n",
" # Reverse for Qiskit bit order (qubit 0 is rightmost)\n",
" rev_target = bitstr[::-1]\n",
" zero_inds = [i for i, b in enumerate(rev_target) if b == \"0\"]\n",
" # Apply X gates to 'open' controls (where bit is 0)\n",
" qc.x(zero_inds)\n",
" # Multi-controlled Z (as MCX conjugated by H)\n",
" if num_qubits == 1:\n",
" qc.z(0)\n",
" else:\n",
" qc.h(num_qubits - 1)\n",
" qc.mcx(list(range(num_qubits - 1)), num_qubits - 1)\n",
" qc.h(num_qubits - 1)\n",
" # Undo X gates\n",
" qc.x(zero_inds)\n",
" return qc, marked_count, marked_list"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "5f5e4675",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['011', '101', '110']\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Completing step 1\n",
"oracle, num_marked_states, marked_states = grover_oracle_hamming_weight(3, 2)\n",
"print(marked_states)\n",
"oracle.draw(output=\"mpl\", style=\"iqp\")"
]
},
{
"cell_type": "markdown",
"id": "f26a8955",
"metadata": {},
"source": [
"ここからのすべてのプロセスは、前の2つの活動と同じである。 簡潔にするため、ここではQiskitパターンのステップをコードコメントのみで示す。\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "63034fc7",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"qiskit_runtime_service._resolve_cloud_instances:WARNING:2025-08-08 14:14:51,686: Default instance not set. Searching all available instances.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_brisbane\n"
]
}
],
"source": [
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"# Completing step 1\n",
"oracle, num_marked_states, marked_states = grover_oracle_hamming_weight(4, 2)\n",
"oracle.draw(output=\"mpl\", style=\"iqp\")\n",
"\n",
"grover_op = grover_operator(oracle)\n",
"grover_op.decompose().draw(output=\"mpl\", style=\"iqp\")\n",
"optimal_num_iterations = math.floor(\n",
" math.pi / (4 * math.asin(math.sqrt(len(marked_states) / 2**grover_op.num_qubits)))\n",
")\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()\n",
"qc.draw(output=\"mpl\", style=\"iqp\")\n",
"\n",
"# Step 2: Optimize for running on real quantum computers\n",
"\n",
"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)\n",
"\n",
"# Step 3: Execute using Qiskit primitives\n",
"# To run on a real quantum computer (this was tested on a Heron r2 processor and used 4 seconds of QPU time)\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()\n",
"\n",
"# 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": "code",
"execution_count": null,
"id": "0f7daf19",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The total depth is 502\n",
"The depth of two-qubit gates is 130\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": "code",
"execution_count": null,
"id": "7c987ff1",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 150,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"num_marked_states"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cf8b6be8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 151,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot_distribution(dist)"
]
},
{
"cell_type": "markdown",
"id": "268508ce",
"metadata": {},
"source": [
"ここでグローバーのアルゴリズムは、確かにハミング重み2の状態を、他のどの状態よりも測定される可能性が非常に高く、およそ1桁高い確率で準備した。\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "494c1799",
"metadata": {},
"source": [
"\n",
"\n",
"### 重要な概念：\n",
"\n",
"このモジュールでは、グローバーのアルゴリズムの主な特徴を学んだ：\n",
"\n",
"* 古典的な非構造化検索アルゴリズムが、空間の大きさに対して線形にスケールするクエリー数を必要とするのに対し、 $N,$ Groverのアルゴリズムは、次のようにスケールするクエリー数を必要とする。 $\\sqrt{N}.$\n",
"* グローバーのアルゴリズムでは、一連の操作（一般に「グローバー演算子」と呼ばれる）を、目標状態が測定される可能性が最適になるように選択された回数（ $t,$ ）繰り返す。\n",
"* Groverのアルゴリズムは、 $t$ より少ない反復回数で実行しても、目標状態を増幅することができる。\n",
"* グローバーのアルゴリズムは計算のクエリーモデルに適合し、一人が検索を制御し、もう一人がオラクルを制御／構築する場合に最も理にかなっている。 また、他の量子計算のサブルーチンとしても有用だろう。\n",
"\n",
"\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
}