diff --git a/translations/ja/algorithm-design/ansatz/ansatz.ipynb b/translations/ja/algorithm-design/ansatz/ansatz.ipynb new file mode 100644 index 00000000..23873ec9 --- /dev/null +++ b/translations/ja/algorithm-design/ansatz/ansatz.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "ansatz": { + "text": "参照演算子と変分形式の組み合わせで、探索する探索空間を記述する。", + "title": "Ansatz" + }, + "variational": { + "text": "パラメーター化されたゲートを一定回数繰り返す層で、コスト関数を最小化するためにアルゴリズム中にゲートのパラメーターを最適化する。", + "title": "変分形式" + } + } + }, + "source": [ + "## Ansatzと変分フォーム\n", + "\n", + "すべての変分アルゴリズムの中心には、状態と状態の違いを分析するという重要なアイデアがあります。状態間の違いは、一連のパラメーターまたは変数から適切に動作するマッピング (たとえば、連続、微分可能) を通じて便利に関連付けられます。したがって、この名前が付けられました。\n", + "\n", + "はじめに、パラメーター化された回路を手作業で構築する方法を探ります。この回路を使って [*変分形式*](gloss:variational) を定義し、変分アルゴリズムが探索するパラメーター化された状態の集合を定義します。そして、この変分形式を参照状態に適用することで、 [*Ansatz*](gloss:ansatz) を構築します。\n", + "\n", + "また、この探索空間を探索する際に、速度と精度のトレードオフをどのように行うかを検討します。\n", + "\n", + "![Ansatz Workflow](images/ansatz_workflow.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## パラメーター化された量子回路\n", + "\n", + "変分アルゴリズムは、有限の $k$ 個のパラメーター $\\vec{\\theta} = (\\theta^0, \\ldots, \\theta^{k-1})$ に依存する量子状態 $|\\psi(\\vec{\\theta})\\rangle$ を探索・比較することで動作します。これらの状態は、パラメーター化された量子回路を用いて準備することができ、そのゲートは調整可能なパラメーターで定義されています。このパラメーター化された量子回路は、特定の角度に縛られることなく作成することが可能です：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit import QuantumCircuit, Parameter\n", + "\n", + "theta = Parameter(\"θ\")\n", + "\n", + "qc = QuantumCircuit(3)\n", + "qc.rx(theta, 0)\n", + "qc.cx(0, 1)\n", + "qc.x(2)\n", + "\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from math import pi\n", + "\n", + "angle_list = [pi / 3, pi / 2]\n", + "circuits = [qc.bind_parameters({theta: angle}) for angle in angle_list]\n", + "\n", + "for circuit in circuits:\n", + " display(circuit.draw(\"mpl\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 変分形式とAnsatz\n", + "\n", + "参照状態 $|\\rho\\rangle$ から目標状態 $|\\psi(\\vec\\theta)\\rangle$ へ反復最適化するために、変分アルゴリズムが探索するパラメーター化された状態の集合を表す変分形式 $U_V(\\vec{\\theta})$ を定義する必要があります：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "|0\\rangle \\xrightarrow{U_R} U_R|0\\rangle\n", + "\n", + "& = |\\rho\\rangle \\xrightarrow{U_V(\\vec{\\theta})} U_A(\\vec{\\theta})|0\\rangle \\\\[1mm]\n", + "\n", + "& = U_V(\\vec{\\theta})U_R|0\\rangle \\\\[1mm]\n", + "\n", + "& = U_V(\\vec{\\theta})|\\rho\\rangle \\\\[1mm]\n", + "\n", + "& = |\\psi(\\vec{\\theta})\\rangle \\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "パラメーター化された状態は、パラメーターに依存しない参照状態 $|\\rho\\rangle$ と、常にパラメーターに依存する変分形式 $U_V(\\vec{\\theta})$ の両方に依存していることに注意してください。 この2つを組み合わせたもの $U_A(\\vec\\theta) := U_V(\\vec\\theta)U_R$ をansatzと呼日ます。\n", + "\n", + "変分アルゴリズムが探索するパラメーター化された状態の集合を表現するために、このansatzを構築するとき、重要な問題に気づきます。次元性です。 $n$ 量子ビットのシステム（ヒルベルト空間）の構成空間には、膨大な数の量子状態が存在します。これを完全に探索するためには、扱いにくい数のパラメーターが必要になります。定量的には、その次元性は $D = 2^{2n}$ です。さらに悪いことに、探索アルゴリズムなどの実行複雑度は、この次元性によって指数関数的に増大し、文献ではしばしば次元の呪いと呼ばれている現象となります。\n", + "\n", + "この欠点に対処するために、最も関連性の高い状態のみを探索するような合理的な制約を変分形式に課すことが一般的です。効率的に切り捨てられたansatzを見つける研究は盛んに行われていますが、ここでは2つの一般的なデザインを取り上げることにします。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ヒューリスティックAnsatzとトレードオフ\n", + "\n", + "次元数を制限するのに役立つ特定の問題に関する情報がない場合、 $2^{2n}$ 未満のパラメーターを持つ任意のパラメーター化された回路ファミリーを試すことができます。しかし、次のような考慮すべきトレードオフがいくつかあります：\n", + "\n", + "- **速度**: 探索空間を縮小することで、アルゴリズムの実行速度を向上させることができます。\n", + "- **精度**: ただし、探索空間を小さくすると、問題の実際の解を除外してしまい、最適な解が得られない可能性があります。\n", + "- **ノイズ**: 深い回路はノイズの影響を受けるため、ansatzの接続性、ゲート、ゲートフィデリティを実験する必要があります。\n", + "\n", + "品質（あるいは解きやすさ）と速度の間には基本的なトレードオフがあります：パラメーターが多ければ多いほど、正確な結果が得られる可能性が高くなりますが、アルゴリズムの実行にかかる時間は長くなってしまうのです。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### N-local 回路\n", + "\n", + "ヒューリスティックansatzで最も広く使われている例の1つが [N-local回路](https://qiskit.org/documentation/apidoc/circuit_library.html#n-local-circuits) です：\n", + "\n", + "- **効率的な実装**: N-local回路は、一般的にシンプルなローカルゲートで構成されており、少数の物理量子ビットを用いて量子コンピューター上で効率的に実装することができます。これにより、量子回路の構築や最適化が容易になります。\n", + "- **重要な相関関係をとらえる**: N-local ansatzは、少ないゲート数でも量子系における量子ビット間の重要な相関を捉えることができます。これは、ローカルゲートが隣接する量子ビットに作用し、量子ビット間にエンタングルメントを生じさせることができるためで、複雑な量子系をシミュレーションする上で重要な意味を持ちます。\n", + "\n", + "これらの回路は、以下のように交互に1回以上繰り返される回転層とエンタングルメント層で構成されています：\n", + "\n", + "- 各層は最大 $N$ 個のゲートで形成され、 $N$ は量子ビット数より小さくなければなりません。\n", + "- 回転層では、ゲートは互いに積み重ねます。[`RX`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RXGate.html) や [`CRZ`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CRZGate.html) のような標準的な回転演算を使用することができます。\n", + "- エンタングルメント層には、エンタングルメントを作る [`とフォリ` ゲート ](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CCXGate.html) や [`CX`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html#qiskit.circuit.library.CXGate) のようなゲートを使用できます。\n", + "- どちらの層も、パラメーター化することもしないこともできますが、少なくとも1つの層はパラメーターを含む必要があります。そうでなければ、1つもパラメーターがないことになり、変化が生まれません！\n", + "- オプションとして、回路の末尾に回転層を追加することもできます。\n", + "\n", + "例えば、 [`RX`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RXGate.html) ゲートと [`CRZ`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CRZGate.html) ゲートで形成される回転ブロック、量子ビット $[0,1,2]$, $[0,2,3]$, $[4,2,1]$ $[3,1,0]$ に作用する [`トフォリ` ゲート](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CCXGate.html) で形成されるエンタングルメントブロックが各層2回の繰り返される $5$ 量子ビットの [`NLocal`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.NLocal.html) 回路を作ってみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import NLocal, CCXGate, CRZGate, RXGate\n", + "from qiskit.circuit import Parameter\n", + "\n", + "theta = Parameter(\"θ\")\n", + "ansatz = NLocal(\n", + " num_qubits=5,\n", + " rotation_blocks=[RXGate(theta), CRZGate(theta)],\n", + " entanglement_blocks=CCXGate(),\n", + " entanglement=[[0, 1, 2], [0, 2, 3], [4, 2, 1], [3, 1, 0]],\n", + " reps=2,\n", + " insert_barriers=True,\n", + ")\n", + "ansatz.decompose().draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above example, the largest gate 上記の例では、最大のゲートは 三量子ビットに作用するトフォリゲートであり、この回路は $3$ local となります。最もよく使われるタイプの $N$ -local回路は、1量子ビット回転ゲートと $2$ 量子ビットエンタングルゲートを持つ [$2$-local]((https://qiskit.org/documentation/stubs/qiskit.circuit.library.TwoLocal.html)) 回路です。\n", + "\n", + "Qiskitの [`TwoLocal`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.TwoLocal.html) クラスを使って、$2$ -local回路を作成してみましょう。構文は `NLocal` と同じですが、いくつかの相違点があります。例えば、 `RX`, `RZ`, `CNOT`, `RZ`, and `CNOT`などのほとんどのゲートは、ゲートをインポートしたり `Parameter` インスタンスを作成したりせずに、文字列として渡すことができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "\n", + "ansatz = TwoLocal(\n", + " num_qubits=5,\n", + " rotation_blocks=[\"rx\", \"rz\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=2,\n", + " insert_barriers=True,\n", + ")\n", + "ansatz.decompose().draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ここでは、各量子ビットが次の量子ビットとエンタングルする、線形エンタングルメント分布を使用しました。他の戦略については、[`TwoLocal` のドキュメント](https://qiskit.org/documentation/stubs/qiskit.circuit.library.TwoLocal.html) を参照してください。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### EfficientSU2\n", + "\n", + "[`EfficientSU2`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.EfficientSU2.html) は、SU(2)にまたがる1量子ビット演算の層と `CX` エンタングルメントのそうで構成されるハードウェアに対して効率の高い回路です。変分量子アルゴリズムの試行波動関数の準備や、機械学習の分類回路として利用できるヒューリスティックなパターンです。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import EfficientSU2\n", + "\n", + "ansatz = EfficientSU2(4, su2_gates=[\"rx\", \"y\"], entanglement=\"linear\", reps=1)\n", + "ansatz.decompose().draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 問題固有のansatze\n", + "\n", + "ヒューリスティックな方法とハードウェア効率の良いansatzeは、素朴な方法で問題を解決するのに役立つ一方、問題固有の知識を使用して、回路の検索空間を特定のタイプに制限することもできます。これにより、検索プロセスの精度を落とすことなく、速度を上げることができるようになります。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 量子化学\n", + "\n", + "化学分野での典型的なアプリケーションは、特定の分子系の基底状態を求めることです。 [*Unitary Coupled-Cluster (UCC)*](https://qiskit.org/ecosystem/nature/stubs/qiskit_nature.second_q.circuit.library.UCC.html) ansatzは当初、基底状態の探索に変分境界を追加し、探索空間の探索速度を向上させるために提案されました。以下の例では、Hartree-Fock近似を参照状態として使用し、Hartree-Fock基底状態からの二重励起でUnitary Coupled-Clusterを使用する例を示します。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "from qiskit_nature.second_q.circuit.library import HartreeFock, UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo\n", + "\n", + "molecule = MoleculeInfo(\n", + " # Coordinates in Angstrom\n", + " symbols=[\"Li\", \"H\"],\n", + " coords=([0.0, 0.0, 0.0], [0.2, 0.0, 0.0]),\n", + " multiplicity=1, # = 2*spin + 1\n", + " charge=0,\n", + ")\n", + "\n", + "driver = PySCFDriver.from_molecule(molecule)\n", + "LiH_problem = driver.run()\n", + "\n", + "mapper = JordanWignerMapper()\n", + "LiH_reference_state = HartreeFock(\n", + " num_spatial_orbitals=LiH_problem.num_spatial_orbitals,\n", + " num_particles=LiH_problem.num_particles,\n", + " qubit_mapper=mapper,\n", + ")\n", + "\n", + "ansatz = UCC(\n", + " num_spatial_orbitals=LiH_problem.num_spatial_orbitals,\n", + " num_particles=LiH_problem.num_particles,\n", + " qubit_mapper=mapper,\n", + " initial_state=LiH_reference_state,\n", + " excitations=2,\n", + ")\n", + "\n", + "ansatz.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 量子機械学習\n", + "\n", + "機械学習で一般的なアプリケーションは、データを2つ以上のカテゴリーに [分類](https://learn.qiskit.org/course/machine-learning/variational-classification) することです。この場合、古典的な特徴量ベクトルを量子ヒルベルト空間にマッピングする特徴量マップに [データ点を符号化](https://learn.qiskit.org/course/machine-learning/data-encoding) する必要があります。古典的なシミュレーションが困難なパラメーター化された量子回路に基づいて量子特徴量マップを構築することは、古典的な機械学習アプローチに対する潜在的な優位性を得るための重要なステップであり、現在活発に研究が行われている分野です。\n", + "\n", + "[ZZFeatureMap](https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html) は、パラメーター化された回路を作成するために使用することができます。特徴量マップ( $x$ )と重みをパラメーターとして渡すための別の変分形式( $\\theta$ )にデータ点を渡します。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import ZZFeatureMap, TwoLocal\n", + "\n", + "data = [0.1, 0.2]\n", + "\n", + "zz_feature_map_reference = ZZFeatureMap(feature_dimension=2, reps=2)\n", + "zz_feature_map_reference = zz_feature_map_reference.bind_parameters(data)\n", + "\n", + "variation_form = TwoLocal(2, [\"ry\", \"rz\"], \"cz\", reps=2)\n", + "vqc_ansatz = zz_feature_map_reference.compose(variation_form)\n", + "vqc_ansatz.decompose().draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このレッスンでは、変分形式を使って探索空間を定義する方法を学びました：\n", + "\n", + "- ゲートが調整可能なパラメータで定義された、 *パラメーター化された* 量子回路で状態を準備します。\n", + "- 速度と精度をトレードオフするansatzeの組み立て方\n", + "- ヒューリスティックなansatze\n", + "- 問題に固有のansatze\n", + "\n", + "このハイレベルな変分の作業は次のようになります：\n", + "\n", + "![Ansatz Circuit](images/ansatz_circuit.png)\n", + "\n", + "各変形パラメーター $\\vec\\theta$ に対して、異なる量子状態が生成されます。最適なパラメーターを見つけるために、問題に応じた *コスト関数* を定義して、ansatzのパラメーターを繰り返し更新する必要があります。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/ansatz/images/ansatz_circuit.png b/translations/ja/algorithm-design/ansatz/images/ansatz_circuit.png new file mode 100644 index 00000000..4aff5d6d Binary files /dev/null and b/translations/ja/algorithm-design/ansatz/images/ansatz_circuit.png differ diff --git a/translations/ja/algorithm-design/ansatz/images/ansatz_workflow.png b/translations/ja/algorithm-design/ansatz/images/ansatz_workflow.png new file mode 100644 index 00000000..2cec5ec4 Binary files /dev/null and b/translations/ja/algorithm-design/ansatz/images/ansatz_workflow.png differ diff --git a/translations/ja/algorithm-design/applications/applications.ipynb b/translations/ja/algorithm-design/applications/applications.ipynb new file mode 100644 index 00000000..eab58a3c --- /dev/null +++ b/translations/ja/algorithm-design/applications/applications.ipynb @@ -0,0 +1,1195 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 例とアプリケーション\n", + "\n", + "このレッスンでは、いくつかの変分アルゴリズムの例とその適用方法について説明します。\n", + "\n", + "- カスタム変分アルゴリズムの書き方\n", + "- 変分アルゴリズムを適用して最小固有値を見つける方法\n", + "- 変分アルゴリズムを利用してアプリケーションのユースケースを解決する方法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 問題の定義\n", + "\n", + "変分アルゴリズムを使用して、次の観測可能量の固有値を見つけたいと想像してください。\n", + "\n", + "$$\n", + "\\hat{O}_1 = 2 II - 2 XX + 3 YY - 3 ZZ,\n", + "$$\n", + "\n", + "この観測可能量は次の固有値を持ちます。\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{c}\n", + "\\lambda_0 = -6 \\\\\n", + "\\lambda_1 = 4 \\\\\n", + "\\lambda_2 = 4 \\\\\n", + "\\lambda_3 = 6\n", + "\\end{array}\n", + "\\right\\}\n", + "$$\n", + "\n", + "そして固有状態：\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{c}\n", + "|\\phi_0\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\\\\\n", + "|\\phi_1\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle - |11\\rangle)\\\\\n", + "|\\phi_2\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle - |10\\rangle)\\\\\n", + "|\\phi_3\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle + |10\\rangle)\n", + "\\end{array}\n", + "\\right\\}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## カスタム VQE\n", + "\n", + "最初に、VQE インスタンスを手動で構築して $\\hat{O}_1$ の最小固有値を見つける方法を調べます。これには、このコースで説明したさまざまなテクニックが組み込まれています。 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit import QuantumCircuit\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", + "import numpy as np\n", + "\n", + "# Add your token below\n", + "service = QiskitRuntimeService(\n", + " channel=\"ibm_quantum\",\n", + ")\n", + "\n", + "def cost_function_vqe(theta):\n", + " observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])\n", + " reference_circuit = QuantumCircuit(2)\n", + " reference_circuit.x(0)\n", + "\n", + " variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + " )\n", + " ansatz = reference_circuit.compose(variational_form)\n", + "\n", + " backend = service.backend(\"ibmq_qasm_simulator\")\n", + " \n", + " # Use estimator to get the expected values corresponding to each ansatz\n", + " estimator = Estimator(session=backend)\n", + " job = estimator.run(ansatz, observable, theta)\n", + " values = job.result().values\n", + "\n", + " return values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このコスト関数を使用して、最適なパラメーターを計算できます" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import COBYLA\n", + "\n", + "initial_theta = np.ones(8)\n", + "optimizer = COBYLA()\n", + "\n", + "optimizer_result = optimizer.minimize(fun=cost_function_vqe, x0=initial_theta)\n", + "\n", + "optimal_parameters = optimizer_result.x\n", + "print(optimal_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "最後に、最適パラメーターを使用して最小固有値を計算できます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])\n", + "reference_circuit = QuantumCircuit(2)\n", + "reference_circuit.x(0)\n", + "\n", + "variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + ")\n", + "ansatz = reference_circuit.compose(variational_form)\n", + "solution = ansatz.bind_parameters(optimal_parameters)\n", + "\n", + "backend = service.backend(\"ibmq_qasm_simulator\")\n", + "estimator = Estimator(session=backend)\n", + "job = estimator.run(solution, observable)\n", + "values = job.result().values\n", + "\n", + "experimental_min_eigenvalue = values[0]\n", + "print(experimental_min_eigenvalue)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy.linalg import eigvalsh\n", + "\n", + "solution_eigenvalue = min(eigvalsh(observable.to_matrix()))\n", + "print(\n", + " f\"Percent error: {abs((experimental_min_eigenvalue - solution_eigenvalue)/solution_eigenvalue):.2e}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ご覧のとおり、結果は理想に非常に近いものになっています。 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Qiskit の VQE の構成" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "便宜上、既存の Qiskit [VQE](https://qiskit.org/documentation/stubs/qiskit.algorithms.minimum_eigensolvers.VQE.html)の実装を使うことができて、最初の観測可能量 $\\hat{O}_1$ の最小固有値を見つけ、すべての出力結果を調べることもできます。\n", + "\n", + "この場合、以下を使用します。\n", + "\n", + "- 参照演算子 $\\equiv I$ の調査を開始して、これにより速度が向上することを示します。\n", + "- Qiskit Terra の[`Estimator`](https://qiskit.org/documentation/stubs/qiskit.primitives.Estimator.html#qiskit.primitives.Estimator)\n", + "- [`SLSQP`](https://qiskit.org/documentation/stubs/qiskit.algorithms.optimizers.SLSQP.html) (つまり、逐次最小二乗法プログラミング) オプティマイザー\n", + "- さらに、 `SLSQP`オプティマイザーの初期ポイントを $\\vec\\theta_0 = (1, \\cdots, 1)$ に設定します。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "from qiskit.algorithms.optimizers import SLSQP\n", + "from qiskit.algorithms.minimum_eigensolvers import VQE\n", + "import numpy as np\n", + "\n", + "estimator = Estimator()\n", + "optimizer = SLSQP()\n", + "ansatz = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + ")\n", + "\n", + "vqe = VQE(estimator, ansatz, optimizer, initial_point=np.ones(8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`VQE`インスタンスを初期化したので、 [`VQE.compute_minimum_eigenvalue`](https://qiskit.org/documentation/stubs/qiskit.algorithms.minimum_eigensolvers.VQE.compute_minimum_eigenvalue.html#qiskit.algorithms.minimum_eigensolvers.VQE.compute_minimum_eigenvalue)メソッドで結果を取得できます。結果を見てみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result = vqe.compute_minimum_eigenvalue(observable)\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`optimizer_result`を見てみましょう:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(result.optimizer_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ただし、これらすべての情報の中で最も重要な部分は固有値です。理論値と比較してみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy.linalg import eigvalsh\n", + "\n", + "eigenvalues = eigvalsh(observable.to_matrix())\n", + "min_eigenvalue = eigenvalues[0]\n", + "\n", + "print(\"EIGENVALUES:\")\n", + "print(f\" - Theoretical: {min_eigenvalue}.\")\n", + "print(f\" - VQE: {result.eigenvalue}\")\n", + "print(\n", + " f\"Percent error >> {abs((result.eigenvalue - min_eigenvalue)/min_eigenvalue):.2e}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ご覧のとおり、結果は理想に非常に近いものになっています。\n", + "\n", + "ただし、固有状態は`results`の一部ではなかったため、まだ見ていません。この目的のために、最適なパラメーター値`result.optimal_parameters` を `results.optimal_circuit`にバインドし、そのバインドされた (つまり、パラメーター化されていない) 回路から[`Statevector`](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.html)を定義します。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import Statevector\n", + "\n", + "optimal_circuit = result.optimal_circuit.bind_parameters(result.optimal_parameters)\n", + "optimal_vector = Statevector(optimal_circuit)\n", + "\n", + "rounded_optimal_vector = np.round(optimal_vector.data, 3)\n", + "print(f\"EIGENSTATE: {rounded_optimal_vector}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この結果は、 $\\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle) \\equiv [\\frac{1}{\\sqrt{2} },0,0,\\frac{1}{\\sqrt{2}}]$ の理論上のものにあまり近くないようです。ただし、固有ベクトルは定数倍まで定義されていることに注意してください。さらに、量子状態は常に正規化されてグローバル位相まで等価であるため、これら 2 つの状態ベクトルが等価であることを簡単に確認できます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numpy.linalg import eigh\n", + "\n", + "_, eigenvectors = eigh(observable.to_matrix())\n", + "min_eigenvector = eigenvectors.T[0] # Note: transpose to extract by index\n", + "\n", + "optimal_vector.equiv(min_eigenvector, atol=1e-4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "得られた状態は、 $10^{-4}$ までは理想的な状態と同等であると結論付けることができます。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 参照状態を追加\n", + "\n", + "前の例では、参照演算子 $U_R$ を使用していません。ここで、理想的な固有状態 $\\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)$ がどのように得られるかを考えてみましょう。次の回路を考えてみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "ideal_qc = QuantumCircuit(2)\n", + "ideal_qc.h(0)\n", + "ideal_qc.cx(0, 1)\n", + "\n", + "ideal_qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この回路が目的の状態になることをすぐに確認できます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Statevector(ideal_qc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "解の状態を準備する回路がどのようになるかを見てきたので、アダマール ゲートを参照回路として使用するのが合理的であるように思われるため、完全な ansatz は次のようになります。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "reference = QuantumCircuit(2)\n", + "reference.h(0)\n", + "# Include barrier to separate reference from variational form\n", + "reference.barrier()\n", + "\n", + "ref_ansatz = ansatz.decompose().compose(reference, front=True)\n", + "\n", + "ref_ansatz.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この新しい回路では、すべてのパラメーターを $0$ に設定して理想的な解に到達できるため、参照回路の選択が妥当であることが確認されます。\n", + "\n", + "ここで、コスト関数の評価、オプティマイザーの反復、および所要時間を前回の試行と比較してみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_evaluations = result.cost_function_evals\n", + "num_iterations = result.optimizer_result.nit\n", + "time = result.optimizer_time\n", + "\n", + "print(\"NO REFERENCE STATE:\")\n", + "print(f\" - Number of evaluations: {num_evaluations}\")\n", + "print(f\" - Number of iterations: {num_iterations}\")\n", + "print(f\" - Time: {time:.5f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# You can change the ansatz of the already defined vqe object instead of creating a new one\n", + "vqe.ansatz = ref_ansatz\n", + "\n", + "ref_result = vqe.compute_minimum_eigenvalue(observable)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_evaluations_ref = ref_result.cost_function_evals\n", + "num_iterations_ref = ref_result.optimizer_result.nit\n", + "time_ref = ref_result.optimizer_time\n", + "\n", + "print(\"ADDED REFERENCE STATE:\")\n", + "print(f\" - Number of evaluations: {num_evaluations_ref}\")\n", + "print(f\" - Number of iterations: {num_iterations_ref}\")\n", + "print(f\" - Time: {time_ref:.5f} seconds\")\n", + "print()\n", + "\n", + "if num_evaluations_ref < num_evaluations:\n", + " print(\">> Number of cost function evaluations improved\")\n", + "elif num_evaluations_ref > num_evaluations:\n", + " print(\">> Number of cost function evaluations worsened\")\n", + "if num_iterations_ref < num_iterations:\n", + " print(\">> Number of iterations improved\")\n", + "elif num_iterations_ref > num_iterations:\n", + " print(\">> Number of iterations worsened\")\n", + "if time_ref < time:\n", + " print(\">> Time improved\")\n", + "elif time_ref > time:\n", + " print(\">> Time worsened\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 初期点の変更" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "参照状態を追加する効果を見たので、異なる初期点 $\\vec{\\theta_0}$ を選択するとどうなるかを見ていきます。特に、 $\\vec{\\theta_0}=(0,0,0,0,6,0,0,0)$ と $\\vec{\\theta_0}=(6,6,6,6,6,6,6,6,6)$を使用します。参照状態が導入されたときに説明したように、すべてのパラメーターが $0$ のときに理想的な解が見つかることを思い出してください。したがって、最初の初期点では、評価、反復、および時間が少なくて済みます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqe.initial_point = [0, 0, 0, 0, 6, 0, 0, 0]\n", + "\n", + "result = vqe.compute_minimum_eigenvalue(observable)\n", + "\n", + "num_evaluations = result.cost_function_evals\n", + "num_iterations = result.optimizer_result.nit\n", + "time = result.optimizer_time\n", + "\n", + "print(f\"INITIAL POINT: {vqe.initial_point}\")\n", + "print(f\" - Number of evaluations: {num_evaluations}\")\n", + "print(f\" - Number of iterations: {num_iterations}\")\n", + "print(f\" - Time: {time:.5f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqe.initial_point = 6 * np.ones(8)\n", + "\n", + "result = vqe.compute_minimum_eigenvalue(observable)\n", + "\n", + "num_evaluations = result.cost_function_evals\n", + "num_iterations = result.optimizer_result.nit\n", + "time = result.optimizer_time\n", + "\n", + "print(f\"INITIAL POINT: {vqe.initial_point}\")\n", + "print(f\" - Number of evaluations: {num_evaluations}\")\n", + "print(f\" - Number of iterations: {num_iterations}\")\n", + "print(f\" - Time: {time:.5f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VQD の例" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ここで、観測可能量の最小固有値だけを探す代わりに、すべての $4$ を探します。前の章の表記 (および Qiskit の[VQD](https://qiskit.org/documentation/stubs/qiskit.algorithms.eigensolvers.VQD.html)クラスの表記) に従うと、これは $k=4$ を意味します。\n", + "\n", + "VQD のコスト関数は次のとおりです。\n", + "\n", + "$$\n", + "C_{l}(\\vec{\\theta}) := \n", + "\\langle \\psi(\\vec{\\theta}) | \\hat{H} | \\psi(\\vec{\\theta})\\rangle + \n", + "\\sum_{j=0}^{l-1}\\beta_j |\\langle \\psi(\\vec{\\theta})| \\psi(\\vec{\\theta^j})\\rangle |^2 \n", + "\\quad \\forall l\\in\\{1,\\cdots,k\\}=\\{1,\\cdots,4\\}\n", + "$$\n", + "\n", + "これは、 `VQD` オブジェクトを定義するときに、ベクトル$\\vec{\\beta}=(\\beta_0,\\cdots,\\beta_{k-1})$ (この場合は $(\\beta_0, \\beta_1, \\beta_2, \\beta_3)$)を引数として渡さなければならないので、特に重要です。\n", + "\n", + "また、QiskitのVQDの実装では、前のノートブックで説明した実効的な観測可能量を考慮する代わりに、 [`ComputeUncompute`](https://qiskit.org/documentation/stubs/qiskit.algorithms.state_fidelities.ComputeUncompute.html) アルゴリズムによって、忠実度 $|\\langle \\psi(\\vec{\\theta})| \\psi(\\vec{\\theta^j})\\rangle |^2$ を直接計算しています。これは `Sampler` Primitiveを使って、回路 $U_A^\\dagger(\\vec{\\theta})U_A(\\vec{\\theta^j})$ に対して $|0\\rangle$ を得る確率をサンプリングするものです。この確率は以下のとおりですから、このことは厳密に機能しています。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\n", + "p_0\n", + "\n", + "& = |\\langle 0|U_A^\\dagger(\\vec{\\theta})U_A(\\vec{\\theta^j})|0\\rangle|^2 \\\\[1mm]\n", + "\n", + "& = |\\big(\\langle 0|U_A^\\dagger(\\vec{\\theta})\\big)\\big(U_A(\\vec{\\theta^j})|0\\rangle\\big)|^2 \\\\[1mm]\n", + "\n", + "& = |\\langle \\psi(\\vec{\\theta}) |\\psi(\\vec{\\theta^j}) \\rangle|^2 \\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "最後に、新しいオプティマイザーを試すために、 SLSQPの代わりにCOBYLAを使用してみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Sampler\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.algorithms.state_fidelities import ComputeUncompute\n", + "from qiskit.algorithms.eigensolvers import VQD\n", + "\n", + "optimizer = COBYLA()\n", + "sampler = Sampler()\n", + "estimator = Estimator()\n", + "fidelity = ComputeUncompute(sampler)\n", + "\n", + "k = 4\n", + "betas = [40, 60, 30, 30]\n", + "\n", + "vqd = VQD(estimator, fidelity, ansatz, optimizer, k=k, betas=betas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "前の例との唯一の API の違いとして、`VQE.compute_minimum_eigenvalue`メソッドを呼び出す代わりに、 [`VQD.compute_eigenvalues`](https://qiskit.org/documentation/stubs/qiskit.algorithms.eigensolvers.VQD.compute_eigenvalues.html)を呼び出すことに注意してください。次の観測可能量を調べることから始めましょう。\n", + "\n", + "$$\n", + "\\hat{O}_2 := 2 II - 3 XX + 2 YY - 4 ZZ\n", + "$$\n", + "\n", + "この観測可能量は次の固有値を持ちます。\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{c}\n", + "\\lambda_0 = -7 \\\\\n", + "\\lambda_1 = 3\\\\\n", + "\\lambda_2 = 5 \\\\\n", + "\\lambda_3 = 7\n", + "\\end{array}\n", + "\\right\\}\n", + "$$\n", + "\n", + "そして固有状態：\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{c}\n", + "|\\phi_0\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\\\\\n", + "|\\phi_1\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle - |11\\rangle)\\\\\n", + "|\\phi_2\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle + |10\\rangle)\\\\\n", + "|\\phi_3\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle - |10\\rangle)\n", + "\\end{array}\n", + "\\right\\}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observable_2 = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -3), (\"YY\", 2), (\"ZZ\", -4)])\n", + "\n", + "result = vqd.compute_eigenvalues(observable_2)\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "取得した[`VQDResult`](https://qiskit.org/documentation/stubs/qiskit.algorithms.eigensolvers.VQDResult.html) は、 `VQEResult`と完全に類似しています。各属性が $i$ 番目の要素が $i$ 番目の固有値に対応するリストであるという点だけが異なります。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "さて、固有値を見たところで、実験の固有ベクトルと理論の固有ベクトルを比較してみましょう：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_circuits = [\n", + " circuit.bind_parameters(parameters)\n", + " for circuit, parameters in zip(result.optimal_circuits, result.optimal_parameters)\n", + "]\n", + "eigenstates = [Statevector(c) for c in optimal_circuits]\n", + "\n", + "for i, (eigenvalue, eigenstate) in enumerate(zip(result.eigenvalues, eigenstates)):\n", + " eigenvalue = eigenvalue.real\n", + " eigenstate = np.round(eigenstate.data, 3).tolist()\n", + " print(f\"RESULT {i}:\")\n", + " print(f\" - {eigenvalue = :.3f}\")\n", + " print(f\" - {eigenstate = }\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "これらの結果は、小さな近似誤差とグローバル位相を除いて、予想される結果と同じです。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ここで、最初に観測可能量 $\\hat{O}_1 := 2 II - 2 XX + 3 YY - 3 ZZ$ についてこの問題を解いてみましょう。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result = vqd.compute_eigenvalues(observable)\n", + "\n", + "optimal_circuits = [\n", + " circuit.bind_parameters(parameters)\n", + " for circuit, parameters in zip(result.optimal_circuits, result.optimal_parameters)\n", + "]\n", + "eigenstates = [Statevector(c) for c in optimal_circuits]\n", + "\n", + "for i, (eigenvalue, eigenstate) in enumerate(zip(result.eigenvalues, eigenstates)):\n", + " eigenvalue = eigenvalue.real\n", + " eigenstate = np.round(eigenstate.data, 3).tolist()\n", + " print(f\"RESULT {i}:\")\n", + " print(f\" - {eigenvalue = :.3f}\")\n", + " print(f\" - {eigenstate = }\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ここで、 $\\lambda_1 = \\lambda_2 = 4$ に対応する固有状態は、予想されるものと同じではありません:\n", + "\n", + "$$\n", + "|\\phi_1\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle - |11\\rangle) \\\\\n", + "|\\phi_2\\rangle = \\frac{1}{\\sqrt{2}}(|01\\rangle + |10\\rangle)\n", + "$$\n", + "\n", + "これは、 $\\lambda_1=\\lambda_2$ のように、複雑な線形結合も同じ固有値を持つ固有状態であるためです。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\alpha_1 |\\phi_1\\rangle + \\alpha_2 |\\phi_2\\rangle\n", + "& = \\frac{1}{\\sqrt{2}}(\\alpha_1 |00\\rangle + \\alpha_2 |01\\rangle - \\alpha_2 |10\\rangle - \\alpha_1 |11\\rangle) \\\\[1mm]\n", + "& \\equiv \\frac{1}{\\sqrt{2}}[\\alpha_1, \\alpha_2, -\\alpha_2, -\\alpha_1]\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "それはまさに、これらの結果で私たちが見ているものです。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ベータの変更" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "インスタンスのレッスンで述べたように、 $\\vec{\\beta}$ の値は固有値の差より大きくなければなりません。 $\\hat{O}_2$ でその条件を満たさない場合に何が起こるか見てみましょう\n", + "\n", + "$$\n", + "\\hat{O}_2 = 2 II - 3 XX + 2 YY - 4 ZZ\n", + "$$\n", + "\n", + "固有値は\n", + "\n", + "$$\n", + "\\left\\{\n", + "\\begin{array}{c}\n", + "\\lambda_0 = -7 \\\\\n", + "\\lambda_1 = 3\\\\\n", + "\\lambda_2 = 5 \\\\\n", + "\\lambda_3 = 7\n", + "\\end{array}\n", + "\\right\\}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqd.betas = np.ones(4)\n", + "result = vqd.compute_eigenvalues(observable_2)\n", + "\n", + "optimal_circuits = [\n", + " circuit.bind_parameters(parameters)\n", + " for circuit, parameters in zip(result.optimal_circuits, result.optimal_parameters)\n", + "]\n", + "eigenstates = [Statevector(c) for c in optimal_circuits]\n", + "\n", + "for i, (eigenvalue, eigenstate) in enumerate(zip(result.eigenvalues, eigenstates)):\n", + " eigenvalue = eigenvalue.real\n", + " eigenstate = np.round(eigenstate.data, 3).tolist()\n", + " print(f\"RESULT {i}:\")\n", + " print(f\" - {eigenvalue = :.3f}\")\n", + " print(f\" - {eigenstate = }\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "今回、オプティマイザーは、すべての固有状態に対する提案された解として、同じ状態 $|\\phi_0\\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)$ を返しますがこれは明らかに誤っています。これは、ベータが小さすぎて、連続するコスト関数の最小固有状態にペナルティを課すことができないために発生します。したがって、アルゴリズムの後の反復で有効な検索スペースから除外されず、可能な最良解として常に選択されるのです。\n", + "\n", + "$\\vec{\\beta}$ の値を試して、固有値の差よりも大きいことを確認することをお勧めします。 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 量子化学: 基底状態と励起エネルギーソルバー\n", + "\n", + "私たちの目的は、観測可能量を表わすエネルギー (ハミルトニアン $\\hat{\\mathcal{H}}$) の期待値を最小化することです。\n", + "\n", + "$$\n", + "\\min_{\\vec\\theta} \\langle\\psi(\\vec\\theta)|\\hat{\\mathcal{H}}|\\psi(\\vec\\theta)\\rangle\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_nature.units import DistanceUnit\n", + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "from qiskit_nature.second_q.circuit.library import HartreeFock, UCC\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "H2_op = SparsePauliOp.from_list(\n", + " [\n", + " (\"II\", -1.052373245772859),\n", + " (\"IZ\", 0.39793742484318045),\n", + " (\"ZI\", -0.39793742484318045),\n", + " (\"ZZ\", -0.01128010425623538),\n", + " (\"XX\", 0.18093119978423156),\n", + " ]\n", + ")\n", + "\n", + "driver = PySCFDriver(\n", + " atom=\"H 0 0 0; H 0 0 0.735\",\n", + " basis=\"sto3g\",\n", + " charge=0,\n", + " spin=0,\n", + " unit=DistanceUnit.ANGSTROM,\n", + ")\n", + "\n", + "h2_problem = driver.run()\n", + "\n", + "mapper = JordanWignerMapper()\n", + "\n", + "h2_reference_state = HartreeFock(\n", + " num_spatial_orbitals=h2_problem.num_spatial_orbitals,\n", + " num_particles=h2_problem.num_particles,\n", + " qubit_mapper=mapper,\n", + ")\n", + "\n", + "ansatz = UCC(\n", + " num_spatial_orbitals=h2_problem.num_spatial_orbitals,\n", + " num_particles=h2_problem.num_particles,\n", + " qubit_mapper=mapper,\n", + " initial_state=h2_reference_state,\n", + " excitations=2,\n", + ")\n", + "\n", + "ansatz.decompose().decompose().draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.minimum_eigensolvers import VQE\n", + "from qiskit.primitives import Sampler, Estimator\n", + "from qiskit.algorithms.state_fidelities import ComputeUncompute\n", + "from qiskit_nature.second_q.algorithms import GroundStateEigensolver\n", + "\n", + "estimator = Estimator()\n", + "sampler = Sampler()\n", + "fidelity = ComputeUncompute(sampler)\n", + "\n", + "vqe = VQE(\n", + " estimator=estimator,\n", + " ansatz=ansatz,\n", + " optimizer=optimizer,\n", + " initial_point=np.zeros(ansatz.num_parameters),\n", + ")\n", + "gse = GroundStateEigensolver(qubit_mapper=mapper, solver=vqe)\n", + "result = gse.solve(h2_problem)\n", + "\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VQD を活用して励起状態を解くこともできます" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.eigensolvers import VQD\n", + "\n", + "h2_operators, _ = gse.get_qubit_operators(h2_problem)\n", + "\n", + "optimizer = COBYLA()\n", + "sampler = Sampler()\n", + "estimator = Estimator()\n", + "fidelity = ComputeUncompute(sampler)\n", + "\n", + "k = 3\n", + "betas = [33, 33, 33]\n", + "\n", + "vqd = VQD(\n", + " estimator=estimator,\n", + " ansatz=ansatz,\n", + " optimizer=optimizer,\n", + " fidelity=fidelity,\n", + " initial_point=np.zeros(ansatz.num_parameters),\n", + " k=k,\n", + " betas=betas,\n", + ")\n", + "result = vqd.compute_eigenvalues(operator=h2_operators)\n", + "vqd_values = result.optimal_values\n", + "print(vqd_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 最適化: マックスカット\n", + "\n", + "マックスカット（Max-Cut）問題とは、グラフの頂点を2つの互いに素な集合に分割し、その2つの集合間の辺の数が最大になるようにする組合せ最適化問題です。より正式には、 $V$ が頂点の集合、 $E$ が辺の集合である無向グラフ $G=(V,E)$ が与えられたとき、マックスカット問題は、頂点を2つの互いに素な部分集合 $S$ と$T$に分割する際に、一方の端点が $S$ にあり他方が $T$ にあるような辺の数が最大となるような分割を求めます。\n", + "\n", + "マックスカットを応用して、クラスタリング、ネットワーク設計、相転移など様々な問題を解くことができます。まず、問題グラフを作成することから始めます：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "\n", + "n = 4\n", + "G = nx.Graph()\n", + "G.add_nodes_from(range(n))\n", + "edge_list = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]\n", + "G.add_weighted_edges_from(edge_list)\n", + "\n", + "colors = [\"red\" for i in range(n)]\n", + "\n", + "\n", + "def draw_graph(G, colors):\n", + " \"\"\"Draws the graph with the chose colors\"\"\"\n", + " layout = nx.shell_layout(G)\n", + " nx.draw_networkx(G, node_color=colors, pos=layout)\n", + " edge_labels = nx.get_edge_attributes(G, \"weight\")\n", + " nx.draw_networkx_edge_labels(G, pos=layout, edge_labels=edge_labels)\n", + "\n", + "\n", + "draw_graph(G, colors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "すべてのエッジの重みに快適にアクセスするには、隣接行列を使用できます。この行列は[networkx.to_numpy_array()](https://networkx.org/documentation/stable/reference/generated/networkx.convert_matrix.to_numpy_array.html)で取得できます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "w = nx.to_numpy_array(G)\n", + "print(w)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[`qiskit_optimization`](https://qiskit.org/documentation/optimization/index.html)モジュールには、隣接行列 $w$ から加重 Max-Cut 問題を定義できる[`Maxcut`](https://qiskit.org/documentation/optimization/stubs/qiskit_optimization.applications.Maxcut.html)というクラスが含まれています。その問題から、前のセクションで[`Maxcut.to_quadratic_program()`](https://qiskit.org/documentation/optimization/stubs/qiskit_optimization.applications.Maxcut.to_quadratic_program.html)を使用して推定した等価な２値最適化問題を得ることができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_optimization.applications import Maxcut\n", + "\n", + "max_cut = Maxcut(w)\n", + "\n", + "quadratic_program = max_cut.to_quadratic_program()\n", + "print(quadratic_program.prettyprint())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この問題は、2値最適化問題として表現できます。 $n$ をグラフのノード数とし、 $0 \\leq i < n$ である各ノード（この場合 $n=4$ ）に対して、バイナリー変数 $x_i$ を考えます。この変数は、ノード $i$ が $1$ のラベルを貼ったグループの1つであれば値 $1$ を持ち、 $0$ とラベルを貼った他のグループの1つであれば値 $0$ を持つことになります。また、ノード $i$ からノード $j$ に至るエッジの重みを $w_{ij}$ （隣接行列 $w$ の要素 $(i,j)$ ）とします。グラフは無向性なので、 $w_{ij}=w_{ji}$ となります。そうすると、問題は以下のコスト関数を最大化するものとして定式化できます：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C(\\vec{x})\n", + "& =\\sum_{i,j=0}^n w_{ij} x_i(1-x_j)\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n w_{ij} x_i - \\sum_{i,j=0}^n w_{ij} x_ix_j\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n w_{ij} x_i - \\sum_{i=0}^n \\sum_{j=0}^i 2w_{ij} x_ix_j\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "この問題を量子コンピューターで解くために、コスト関数を観測可能量の期待値として表現します。ただし、Qiskit が自然に認めている観測可能量は、 $0$ と $1$ の代わりに固有値 $1$ と $-1$ を持つパウリ演算子で構成されています。そのため、変数を次のように変更します。\n", + "\n", + "ここで、 $\\vec{x}=(x_0,x_1,\\cdots ,x_{n-1})$ です。隣接行列 $w$ を使って、すべてのエッジの重みに快適にアクセスすることができます。これはコスト関数を求めるのに使われます：\n", + "\n", + "$$\n", + "z_i = 1-2x_i \\rightarrow x_i = \\frac{1-z_i}{2}\n", + "$$\n", + "\n", + "これは、次のことを意味します。\n", + "\n", + "$$\n", + "\\begin{array}{lcl} x_i=0 & \\rightarrow & z_i=1 \\\\ x_i=1 & \\rightarrow & z_i=-1.\\end{array}\n", + "$$\n", + "\n", + "したがって、最大化したい新しいコスト関数は次のとおりです。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C(\\vec{z})\n", + "& = \\sum_{i,j=0}^n w_{ij} \\bigg(\\frac{1-z_i}{2}\\bigg)\\bigg(1-\\frac{1-z_j}{2}\\bigg)\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n \\frac{w_{ij}}{4} - \\sum_{i,j=0}^n \\frac{w_{ij}}{4} z_iz_j\\\\[1mm]\n", + "\n", + "& = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} z_iz_j\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "さらに、量子コンピューターの自然な傾向として、最大値ではなく最小値（通常は最低エネルギー）を見つけるので、 $C(\\vec{z})$ を最大化するのではなく、最小化します：\n", + "\n", + "$$\n", + "-C(\\vec{z}) = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} z_iz_j - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2}\n", + "$$\n", + "\n", + "$-1$ と $1$ の値を持つ変数を最小化するためのコスト関数ができたので、次のようにパウリの $Z$ との類推を行うことができます。\n", + "\n", + "$$\n", + "z_i \\equiv Z_i = \\overbrace{I}^{n-1}\\otimes ... \\otimes \\overbrace{Z}^{i} \\otimes ... \\otimes \\overbrace{I}^{0}\n", + "$$\n", + "\n", + "つまり、変数 $z_i$ は、量子ビット $i$ に作用する $Z$ ゲートと同等になります。さらに：\n", + "\n", + "$$\n", + "Z_i|x_{n-1}\\cdots x_0\\rangle = z_i|x_{n-1}\\cdots x_0\\rangle \\rightarrow \\langle x_{n-1}\\cdots x_0 |Z_i|x_{n-1}\\cdots x_0\\rangle = z_i\n", + "$$\n", + "\n", + "次に、検討する観測可能量は次のとおりです。\n", + "\n", + "$$\n", + "\\hat{H} = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} Z_iZ_j\n", + "$$\n", + "\n", + "後で独立項を追加する必要があります。\n", + "\n", + "$$\n", + "\\texttt{offset} = - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2}\n", + "$$\n", + "\n", + "この変換は、[`QuadraticProgram.to_ising()`](https://qiskit.org/documentation/optimization/stubs/qiskit_optimization.QuadraticProgram.to_ising.html)で行うことができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observable, offset = quadratic_program.to_ising()\n", + "print(\"Offset:\", offset)\n", + "print(\"Ising Hamiltonian:\")\n", + "print(str(observable))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VQE インスタンスを使用して、次のように最適なパラメーターを見つけることができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Estimator\n", + "from qiskit.algorithms.minimum_eigensolvers import VQE\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.circuit.library import TwoLocal\n", + "import numpy as np\n", + "\n", + "ansatz = TwoLocal(observable.num_qubits, \"rx\", reps=1)\n", + "optimizer = COBYLA()\n", + "\n", + "vqe = VQE(\n", + " estimator=Estimator(),\n", + " ansatz=ansatz,\n", + " optimizer=optimizer,\n", + " initial_point=np.zeros(ansatz.num_parameters),\n", + ")\n", + "\n", + "result = vqe.compute_minimum_eigenvalue(observable)\n", + "\n", + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import Statevector\n", + "\n", + "optimal_circuit = result.optimal_circuit.bind_parameters(result.optimal_parameters)\n", + "\n", + "x = max_cut.sample_most_likely(Statevector(optimal_circuit))\n", + "print(\"energy:\", result.eigenvalue.real)\n", + "print(\"time:\", result.optimizer_time)\n", + "print(\"max-cut objective:\", result.eigenvalue.real + offset)\n", + "print(\"solution:\", x)\n", + "print(\"solution objective:\", quadratic_program.objective.evaluate(x))\n", + "\n", + "# plot results\n", + "colors = [\"red\" if x[i] == 0 else \"orange\" for i in range(n)]\n", + "draw_graph(G, colors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このレッスンでは、次のことを学びました。\n", + "\n", + "- カスタム変分アルゴリズムの書き方\n", + "- 変分アルゴリズムを適用して最小固有値を見つける方法\n", + "- 変分アルゴリズムを利用してアプリケーションのユースケースを解く方法\n", + "\n", + "最終レッスンに進み、評価を受けてバッジを獲得しましょう!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/badge/badge.ipynb b/translations/ja/algorithm-design/badge/badge.ipynb new file mode 100644 index 00000000..cce31af0 --- /dev/null +++ b/translations/ja/algorithm-design/badge/badge.ipynb @@ -0,0 +1,52 @@ +{ + "cells": [ + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## バッジの取得\n", + "\n", + "変分アルゴリズムデザインのコースを修了された方、おめでとうございます。評価とバッジに進む前に、以下の1分間のアンケートにお答えください！\n", + "\n", + "\n", + " " + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## バッジ評価へのリンク\n", + "\n", + "[この評価](https://challenges.quantum-computing.ibm.com/algorithm-design) はオープンブックで、このコースで学んだ概念的な知識と実践的な知識をテストします。このコースはいつでも自由に戻って参照することができます！" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/cost_function/cost_function.ipynb b/translations/ja/algorithm-design/cost_function/cost_function.ipynb new file mode 100644 index 00000000..2afac2f3 --- /dev/null +++ b/translations/ja/algorithm-design/cost_function/cost_function.ipynb @@ -0,0 +1,940 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## コスト関数\n", + "\n", + "このレッスンでは、 *コスト関数* を評価する方法について学びます：\n", + "\n", + "- まず、 [Qiskit Runtime primitives](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/primitives.html) について学びます。\n", + "- *コスト関数* $C(\\vec\\theta)$ を定義します。これは、オプティマイザーが最小化（または最大化）するための問題の目標を定義する問題固有の関数です。\n", + "- Qiskit Runtime primitiveで測定のストラテジーを定義し、速度と精度を最適化します。\n", + "\n", + " \n", + "\n", + "![Cost function workflow](images/cost_function_workflow.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "primitives": { + "text": "基本的・基礎的な操作やデータ型。Qiskitは、変分アルゴリズムのような複雑なワークロードを簡単に構築するためのビルディングブロックとして、SamplerとEstimatorのprimitiveを備えています。", + "title": "Primitive" + } + } + }, + "source": [ + "## Primitive\n", + "\n", + "古典的なものであれ量子的なものであれ、すべての物理系は異なる状態で存在することができます。例えば、道路を走る車は、その状態を特徴づける特定の質量、位置、速度、または加速度を持つことができます。同様に、量子系も異なる構成や状態を持つことができますが、測定や状態変化の扱い方が古典系と異なります。そのため、 *重ね合わせ* や *エンタングルメント* など、量子力学にしかないユニークな性質が生まれます。車の状態を速度や加速度などの物理的特性で表現できるように、量子系の状態も数学的な対象である *観測量* を用いて表現することができます。\n", + "\n", + "量子力学では、状態は正規化された複素列ベクトル、または *ケット* ( $|\\psi\\rangle$ )で表され、観測量はケットに作用するエルミート線形演算子( $\\hat{H}=\\hat{H}^{\\dagger}$ ) です。観測量の固有ベクトル ( $|\\lambda\\rangle$ ) は*固有状態*と呼ばれます。その固有状態( $|\\lambda\\rangle$ ) の一つで観測量を測定すると、対応する固有値( $\\lambda$ )を読み出すことができます。\n", + "\n", + "量子系をどのように測定するのか、何を測定できるのか疑問に思っている方に、Qiskitは2つの [primitive](gloss:primitives) を提供しています：\n", + "\n", + "- `Sampler`: 量子状態 $|\\psi\\rangle$ が与えられたとき、このprimitiveは、各計算基底状態の確率を求めます。\n", + "- `Estimator`: 量子観測量 $\\hat{H}$ と状態 $|\\psi\\rangle$ が与えられたとき、このprimitiveは $\\hat{H}$ の期待値を計算します。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sampler primitive\n", + "\n", + " `Sampler` primitiveは、状態 $|\\psi\\rangle$ を準備する量子回路がある場合、計算基底で各可能な状態 $|k\\rangle$ を得る確率を計算します。つまり以下を計算します：\n", + "\n", + "$$\n", + "p_k = |\\langle k | \\psi \\rangle|^2 \\quad \\forall k \\in \\mathbb{Z}_2^n \\equiv \\{0,1,\\cdots,2^n-1\\},\n", + "$$\n", + "\n", + "ここで、 $n$ は量子ビットの数、 $k$ は出力可能なバイナリー文字列 $\\{0,1\\}^n$ の整数表現（すなわち、整数の基底 $2$ ）です。\n", + "\n", + " [Qiskit Runtime](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.Sampler.html) の `Sampler` は、量子デバイス上で回路を複数回実行し、実行ごとに測定を行い、回収したビット列から確率分布を再構築します。実行回数（ *ショット数* ）が多いほど精度の高い結果が得られますが、その分時間と量子リソースが必要になります。\n", + "\n", + "しかし、可能な出力の数は量子ビット数 $n$ （すなわち $2^n$ ）に対して指数関数的に増加するため、 *密な* 確率分布をえるためには、ショット数も同様に指数関数的に増加する必要があります。したがって、 `Sampler` は、 疎な 確率分布に対してのみ効率的です。つまり、ターゲットとする状態 $|\\psi\\rangle$ は、計算基底状態の線形結合として表現可能でなければならず、項の数は量子ビット数に対して最大でも多項式に増加するものである必要があります\n", + "\n", + "$$\n", + "|\\psi\\rangle = \\sum^{\\text{Poly}(n)}_k w_k |k\\rangle.\n", + "$$\n", + "\n", + "また、`Sampler` は、可能な全状態のサブセットを表す回路のサブセクションから確率を取得するように構成することができます。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "pauli": { + "text": "量子コンピューターにおいて、量子状態を表現・操作するために一般的に用いられる行列の集合で、恒等行列と3つのパウリ行列（X、Y、Z）で構成されます。", + "title": "パウリ演算子" + } + } + }, + "source": [ + "### Estimator primitive\n", + "\n", + "`Estimator` primitiveは、量子状態 $|\\psi\\rangle$ に対する観測量 $\\hat{H}$ の期待値を計算します。ここで、観測量の確率 $p_\\lambda = |\\langle\\lambda|\\psi\\rangle|^2$ として表現でき、 $|\\lambda\\rangle$ は観測量 $\\hat{H}$ の固有状態です。期待値とは、状態$ |\\psi\\rangle$ を測定したときに得られるすべての可能な結果 $\\lambda$ （すなわち観測量の固有値）の平均を、対応する確率で重み付けしたものと定義されます：\n", + "\n", + "$$\n", + "\\langle\\hat{H}\\rangle_\\psi := \\sum_\\lambda p_\\lambda \\lambda = \\langle \\psi | \\hat{H} | \\psi \\rangle\n", + "$$\n", + "\n", + "しかし、観測量の期待値を計算することは、その固有基底を知らないことが多いため、必ずしも可能ではありません。[Qiskit Runtime](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.Estimator.html) の `Estimator` は、複雑な代数的処理を用いて、観測量を固有基底がわかっている他の観測量の組み合わせに分解することで、実際の量子デバイスでの期待値を推定します。\n", + "\n", + "簡単に言うと、 `Estimator` は、測定方法が分からない観測量を、 [パウリ演算子](gloss:pauli) と呼ばれるより簡単で測定可能な観測量に分解します。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "どんな演算子も $4^n$ 個のパウリ演算子の組み合わせで表すことができます。\n", + "\n", + "$$\n", + "\\hat{P}_k := \n", + "\\sigma_{k_{n-1}}\\otimes \\cdots \\otimes \\sigma_{k_0} \\quad \n", + "\\forall k \\in \\mathbb{Z}_4^n \\equiv \\{0,1,\\cdots,4^n-1\\}, \\\\\n", + "$$\n", + "\n", + "よって\n", + "\n", + "$$\n", + "\\hat{H} = \\sum^{4^n-1}_{k=0} w_k \\hat{P}_k\n", + "$$\n", + "\n", + "ここで、 $n$ は量子ビット数、 $k_l \\in \\mathbb{Z}_4 \\equiv \\{0, 1, 2, 3\\}$ (つまり整数の基底 $4$ ) の $k \\equiv k_{n-1} \\cdots k_0$ であり、 $(\\sigma_0, \\sigma_1, \\sigma_2, \\sigma_3) := (I, X, Y, Z)$ です。\n", + "\n", + "この分解を行った後、`Estimator` は各観測量 $\\hat{P}_k$ に対して（つまり元の回路から）新しい回路 $V_k|\\psi\\rangle$ を導出し、計算基底においてパウリ観測量を効果的に *対角化* し、測定します。パウリ観測量を容易に測定できるのは、 $V_k$ を前もって知っているからであり、他の観測量では一般にそうではありません。\n", + "\n", + "各 `{latex} \\hat{P}_{k}` について、 `Estimator` は対応する回路を量子デバイス上で複数回実行し、計算基底の出力状態を測定し、各出力 $j$ を得る確率 $p_{kj}$ を計算します。次に、各出力 $j$ に対応する $P_k$ の固有値 $\\lambda_{kj}$ を探し、 $w_k$ を掛け、全ての結果を加算して、与えられた状態 $|\\psi\\rangle$ に対する観測量 $\\hat{H}$ の期待値を求めます。\n", + "\n", + "$$\n", + "\\langle\\hat{H}\\rangle_\\psi = \n", + "\\sum_{k=0}^{4^n-1} w_k \\sum_{j=0}^{2^n-1}p_{kj} \\lambda_{kj},\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "sampling": { + "text": "1つまたは複数の物事を数回に分けて測定すること。", + "title": "Sampling" + } + } + }, + "source": [ + "$4^n$ 個のパウリの期待値を計算するのは非現実的（つまり指数関数的に大きくなる）なので、 `Estimator` は大量の $w_k$ がゼロのとき（つまり *密*ではなく*疎* のPauli分解）だけ効率化できます。形式的には、この計算が *効率的に解ける* ためには、ゼロでない項の数が量子ビット数 $n$ に対して最大で多項式に増加しなければならないと言うことになります： $\\hat{H} = \\sum^{\\text{Poly}(n)}_k w_k \\hat{P}_k.$\n", + "\n", + "読者は、確率 [サンプリング](gloss:sampling) も `Sampler` で説明したように効率的である必要があるという暗黙の仮定に気づくかもしれません。つまり、\n", + "\n", + "$$\n", + "\\langle\\hat{H}\\rangle_\\psi = \n", + "\\sum_{k}^{\\text{Poly}(n)} w_k \\sum_{j}^{\\text{Poly}(n)}p_{kj} \\lambda_{kj}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 期待値算出のためのガイド例\n", + "\n", + "1量子ビット状態 $|+\\rangle := H|0\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle)$ とその観測量を以下のように想定します：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\hat{H}\n", + "& = \\begin{pmatrix} \n", + "-1 & 2 \\\\\n", + "2 & -1 \\\\\n", + "\\end{pmatrix}\\\\[1mm]\n", + "& = 2X - Z\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "理論的な期待値は $\\langle\\hat{H}\\rangle_+ = \\langle+|\\hat{H}|+\\rangle = 2$ です。\n", + "\n", + "この観測量を測定する方法を知らないので、その期待値を直接計算することはできず、 $\\langle\\hat{H}\\rangle_+ = 2\\langle X \\rangle_+ - \\langle Z \\rangle_+ $ と再表現する必要があります。これは、 $\\langle+|X|+\\rangle = 1$ 、 $\\langle+|Z|+\\rangle = 0$ であることに注意すれば、同じ結果になることを示すことができます。\n", + "\n", + " $\\langle X \\rangle_+$ と $\\langle Z \\rangle_+$ を直接計算する方法を説明します。 $X$ と $Z$ は交換しない（つまり同じ固有基底を共有しない）ので、同時に測定することはできず、補助回路が必要です：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "# The following code will work for any other initial single-qubit state and observable\n", + "original_circuit = QuantumCircuit(1)\n", + "original_circuit.h(0)\n", + "\n", + "H = SparsePauliOp([\"X\", \"Z\"], [2, -1])\n", + "\n", + "aux_circuits = []\n", + "for pauli in H.paulis:\n", + " aux_circ = original_circuit.copy()\n", + " aux_circ.barrier()\n", + " if str(pauli) == \"X\":\n", + " aux_circ.h(0)\n", + " elif str(pauli) == \"Y\":\n", + " aux_circ.sdg(0)\n", + " aux_circ.h(0)\n", + " else:\n", + " aux_circ.i(0)\n", + " aux_circ.measure_all()\n", + " aux_circuits.append(aux_circ)\n", + "\n", + "\n", + "print(\"Original circuit:\")\n", + "display(original_circuit.draw(\"mpl\"))\n", + "for (circuit, pauli) in zip(aux_circuits, H.paulis):\n", + " print(f\"Auxiliary circuit for {str(pauli)}\")\n", + " display(circuit.draw(\"mpl\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "あとは、 `Sampler` を使って手動で計算を行い、 `Estimator` で結果を確認します：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.primitives import Sampler, Estimator\n", + "from qiskit.circuit.library import IGate, ZGate\n", + "import numpy as np\n", + "\n", + "\n", + "## SAMPLER\n", + "sampler = Sampler()\n", + "job = sampler.run(aux_circuits)\n", + "probability_dists = job.result().quasi_dists\n", + "\n", + "expvals = []\n", + "for dist, pauli in zip(probability_dists, H.paulis):\n", + " val = 0\n", + " if str(pauli) == \"I\":\n", + " Lambda = IGate().to_matrix().real\n", + " else:\n", + " Lambda = ZGate().to_matrix().real\n", + " val += Lambda[0][0] * dist.get(0, 0)\n", + " val += Lambda[1][1] * dist.get(1, 0)\n", + " expvals.append(val)\n", + "\n", + "\n", + "print(\"Sampler results:\")\n", + "for (pauli, expval) in zip(H.paulis, expvals):\n", + " print(f\" >> Expected value of {str(pauli)}: {expval:.5f}\")\n", + "\n", + "total_expval = np.sum(H.coeffs * expvals).real\n", + "print(f\" >> Total expected value: {total_expval:.5f}\")\n", + "\n", + "\n", + "## ESTIMATOR\n", + "observables = [\n", + " *H.paulis,\n", + " H,\n", + "] # Note: run for individual Paulis as well as full observable H\n", + "\n", + "estimator = Estimator()\n", + "job = estimator.run([original_circuit] * len(observables), observables)\n", + "estimator_expvals = job.result().values\n", + "\n", + "print(\"Estimator results:\")\n", + "for (obs, expval) in zip(observables, estimator_expvals):\n", + " if obs is not H:\n", + " print(f\" >> Expected value of {str(obs)}: {expval:.5f}\")\n", + " else:\n", + " print(f\" >> Total expected value: {expval:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数学的厳密性（オプション）\n", + "\n", + "$|\\psi\\rangle$ を $\\hat{H}$ の固有状態の基底 $|\\psi\\rangle = \\sum_\\lambda a_\\lambda |\\lambda\\rangle$ に関して表現すると、次のようになります。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle \\psi | \\hat{H} | \\psi \\rangle\n", + "& = \\bigg(\\sum_{\\lambda'}a^*_{\\lambda'} \\langle \\lambda'|\\bigg) \\hat{H} \n", + " \\bigg(\\sum_{\\lambda} a_\\lambda | \\lambda\\rangle\\bigg)\\\\[1mm]\n", + "\n", + "& = \\sum_{\\lambda}\\sum_{\\lambda'} a^*_{\\lambda'}a_{\\lambda} \n", + " \\langle \\lambda'|\\hat{H}| \\lambda\\rangle\\\\[1mm]\n", + "\n", + "& = \\sum_{\\lambda}\\sum_{\\lambda'} a^*_{\\lambda'}a_{\\lambda} \\lambda \n", + "\\langle \\lambda'| \\lambda\\rangle\\\\[1mm]\n", + "\n", + "& = \\sum_{\\lambda}\\sum_{\\lambda'} a^*_{\\lambda'}a_{\\lambda} \\lambda \n", + "\\cdot \\delta_{\\lambda, \\lambda'}\\\\[1mm]\n", + "\n", + "& = \\sum_\\lambda |a_\\lambda|^2 \\lambda\\\\[1mm]\n", + "\n", + "& = \\sum_\\lambda p_\\lambda \\lambda\\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "hermitian": { + "text": "エルミート行列とは、自身の共役転置と等しい正方行列、または自己共役である線形演算子のことです。", + "title": "エルミート" + } + } + }, + "source": [ + "観測対象 $\\hat{H}$ の固有値や固有状態は分からないので、まずその対角化を考える必要があります。 $\\hat{H}$ が [エルミート](gloss:hermitian) であることを考えると、$\\hat{H}=V^\\dagger \\Lambda V$ となるようなユニタリー変換 $V$ が存在し、 $\\Lambda$ は固有値の対角行列なので、 $j\\neq k$ なら $\\langle j | \\Lambda | k \\rangle = 0$ で $\\langle j | \\Lambda | j \\rangle = \\lambda_j$　です。\n", + "\n", + "これは、期待値が次のように書き換えられることを意味します：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle\\psi|\\hat{H}|\\psi\\rangle\n", + "& = \\langle\\psi|V^\\dagger \\Lambda V|\\psi\\rangle\\\\[1mm]\n", + "\n", + "& = \\langle\\psi|V^\\dagger \\bigg(\\sum_{j=0}^{2^n-1} |j\\rangle \n", + "\\langle j|\\bigg) \\Lambda \\bigg(\\sum_{k=0}^{2^n-1} |k\\rangle \\langle k|\\bigg) V|\\psi\\rangle\\\\[1mm]\n", + "\n", + "& = \\sum_{j=0}^{2^n-1} \\sum_{k=0}^{2^n-1}\\langle\\psi|V^\\dagger |j\\rangle \n", + "\\langle j| \\Lambda |k\\rangle \\langle k| V|\\psi\\rangle\\\\[1mm]\n", + "\n", + "& = \\sum_{j=0}^{2^n-1}\\langle\\psi|V^\\dagger |j\\rangle \n", + "\\langle j| \\Lambda |j\\rangle \\langle j| V|\\psi\\rangle\\\\[1mm]\n", + "\n", + "& = \\sum_{j=0}^{2^n-1}|\\langle j| V|\\psi\\rangle|^2 \\lambda_j\\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "系が $|\\phi\\rangle = V |\\psi\\rangle$ の状態にあるとき、 $| j\\rangle$ を測定する確率が $p_j = |\\langle j|\\phi \\rangle|^2$ であることを考えると、上記の期待値は次のように表すことができる：\n", + "\n", + "$$\n", + "\\langle\\psi|\\hat{H}|\\psi\\rangle = \n", + "\\sum_{j=0}^{2^n-1} p_j \\lambda_j.\n", + "$$\n", + "\n", + "確率は $|\\psi\\rangle$ ではなく、状態 $V |\\psi\\rangle$ から取られることが非常に重要です。これが行列 $V$ が絶対に必要な理由です。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "行列 $V$ と固有値 $\\Lambda$ をどうやって求めるのか、疑問に思うかもしれません。もし、すでに固有値があれば、変分アルゴリズムの目的はこの $\\hat{H}$ の固有値を求めることなので、量子コンピューターを使う必要はないでしょう。\n", + "\n", + "幸い、それを回避する方法があります：任意の $2^n \\times 2^n$ 行列は、 $n$ 個のパウリ行列と恒等演算子の $4^n$ 個のテンソル積の線形結合として書くことができ、これらはすべて、既知の $V$ と $\\Lambda$ を持つエルミート行列でありユニタリー行列です。 これが、Runtimeの `Estimator` が内部で行っていることで、`Estimator` は任意の [Operator](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Operator.html) オブジェクトを[SparsePauliOp](https://qiskit.org/documentation/stubs/qiskit.quantum_info.SparsePauliOp.html) に分解しています。\n", + "\n", + "ここでは、使用可能な演算子を紹介します：\n", + "\n", + "$$\n", + "\\begin{array}{c|c|c|c}\n", + " \\text{Operator} & \\sigma & V & \\Lambda \\\\[1mm]\n", + " \\hline\n", + " I & \\sigma_0 = \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix} & V_0 = I & \\Lambda_0 = I = \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix} \\\\[4mm]\n", + "\n", + " X & \\sigma_1 = \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} & V_1 = H =\\frac{1}{\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix} & \\Lambda_1 = \\sigma_3 = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\\\[4mm]\n", + "\n", + " Y & \\sigma_2 = \\begin{pmatrix} 0 & -i \\\\ i & 0 \\end{pmatrix} & V_2 = HS^\\dagger =\\frac{1}{\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}\\cdot \\begin{pmatrix} 1 & 0 \\\\ 0 & -i \\end{pmatrix} = \\frac{1}{\\sqrt{2}} \\begin{pmatrix} 1 & -i \\\\ 1 & i \\end{pmatrix}\\quad & \\Lambda_2 = \\sigma_3 = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\\\[4mm]\n", + "\n", + " Z & \\sigma_3 = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} & V_3 = I & \\Lambda_3 = \\sigma_3 = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}\n", + "\\end{array}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "では、 $\\hat{H}$ をパウリ演算子と恒等演算子に関して書き換えてみましょう：\n", + "\n", + "$$\n", + "\\hat{H} = \n", + "\\sum_{k_{n-1}=0}^3...\n", + "\\sum_{k_0=0}^3 w_{k_{n-1}...k_0} \n", + "\\sigma_{k_{n-1}}\\otimes ... \\otimes \\sigma_{k_0} = \\sum_{k=0}^{4^n-1} w_k \\hat{P}_k,\n", + "$$\n", + "\n", + "ここで、 $k = \\sum_{l=0}^{n-1} 4^l k_l \\equiv k_{n-1}...k_0$ は $k_{n-1},...,k_0\\in \\{0,1,2,3\\}$ (つまり基底 $4$ )であり、`{latex} \\hat{P}_{k} := \\sigma_{k_{n-1}}\\otimes ... \\otimes \\sigma_{k_0}`:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle\\psi|\\hat{H}|\\psi\\rangle\n", + "& = \\sum_{k=0}^{4^n-1} w_k \n", + "\\sum_{j=0}^{2^n-1}|\\langle j| V_k|\\psi\\rangle|^2 \\langle j| \\Lambda_k |j\\rangle \\\\[1mm]\n", + "\n", + "& = \\sum_{k=0}^{4^n-1} w_k \\sum_{j=0}^{2^n-1}p_{kj} \\lambda_{kj}, \\\\[1mm]\n", + "\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "ここで $V_k := V_{k_{n-1}}\\otimes ... \\otimes V_{k_0}$ と $\\Lambda_k := \\Lambda_{k_{n-1}}\\otimes ... \\otimes \\Lambda_{k_0}$ は $\\hat{P_k}=V_k^\\dagger \\Lambda_k V_k$ です。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "oracle": { + "text": " 特定の機能を果たすが、その内部構造が不明な仮想的な装置またはソフトウェア・コンポーネント。ユーザーはブラックボックスの入力と出力しか知らず、ブラックボックスが入力を処理して出力を生成する方法については知らない。", + "title": "ブラックボックスオラクル" + } + } + }, + "source": [ + "## コスト関数\n", + "\n", + "一般に、コスト関数は、問題のゴールと、そのゴールに対して試行状態がどの程度うまくいっているかを記述するために使用されます。この定義は、化学、機械学習、金融、最適化など、さまざまな例に適用することができます。\n", + "\n", + "あるシステムの基底状態を求めるという簡単な例を考えてみましょう。我々の目的は、エネルギーを表す観測量（ハミルトニアン $\\hat{\\mathcal{H}}$ ）の期待値を最小化することです：\n", + "\n", + "$$\n", + "\\min_{\\vec\\theta} \\langle\\psi(\\vec\\theta)|\\hat{\\mathcal{H}}|\\psi(\\vec\\theta)\\rangle\n", + "$$\n", + "\n", + "[*Estimator* primitive](https://github.com/qiskit-community/prototype-zne/blob/main/docs/tutorials/0-estimator.ipynb) を使用して期待値を評価し、この値をオプティマイザーに渡して最小化することができます。最適化が成功すれば、最適なパラメーター値のセット $\\vec\\theta^*$ が返され、そこから提案された解の状態 $|\\psi(\\vec\\theta^*)\\rangle$ を構築し、観測された期待値を $C(\\vec\\theta^*)$ として計算することができるようになります。\n", + "\n", + "私たちが考えている状態の限られたセットに対してのみ、コスト関数を最小化することができることに注目してください。このことから、2つの別々の可能性があることがわかります：\n", + "\n", + "- **我々のansatzが、探索空間全体で解の状態を定義していない**: この場合、オプティマイザーは解を見つけることができないので、探索空間をより正確に表現できるかもしれない他のansatzを試してみる必要があります。\n", + "- **オプティマイザーが、有効な解を見つけることができない**: 最適化には、大域的な定義と局所的な定義があります。この意味については、後のセクションで説明します。\n", + "\n", + "全体として、私たちは古典的な最適化ループを実行しますが、コスト関数の評価を量子コンピューターに依存することになります。この観点から、最適化は純粋に古典的な取り組みであり、オプティマイザーがコスト関数を評価する必要があるたびに、 [*ブラックボックスの量子オラクル*](gloss:oracle) を呼び出すと考えることができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit import QuantumCircuit\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", + "\n", + "# Add your token below\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", + "\n", + "def cost_function_vqe(theta):\n", + " observable = SparsePauliOp.from_list([(\"XX\", 1), (\"YY\", -3)])\n", + "\n", + " reference_circuit = QuantumCircuit(2)\n", + " reference_circuit.x(0)\n", + "\n", + " variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + " )\n", + " ansatz = reference_circuit.compose(variational_form)\n", + "\n", + " backend = service.backend(\"ibmq_qasm_simulator\")\n", + " \n", + " # Use estimator to get the expected values corresponding to each ansatz\n", + " estimator = Estimator(session=backend)\n", + " job = estimator.run(ansatz, observable, theta)\n", + " values = job.result().values\n", + "\n", + " return values\n", + "\n", + "\n", + "theta_list = (2 * np.pi * np.random.rand(1, 8)).tolist()\n", + "cost_function_vqe(theta_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 物理でないシステムへのマッピング例\n", + "\n", + "マックスカット（Max-Cut）問題とは、グラフの頂点を2つの不連続な集合に分割し、その2つの集合間の辺の数が最大になるようにする組合せ最適化問題です。より正式には、 $V$ が頂点の集合、 $E$ が辺の集合である無向グラフ $G=(V,E)$ が与えられたとき、マックスカット問題は、頂点を2つの不連続な部分集合、 $S$ と$T$ Tに分割する際に、一方の端点が $S$ にあり他方が $T$ にあるような辺の数が最大となるように求めます。\n", + "\n", + "マックスカットを応用して、クラスタリング、ネットワーク設計、相転移など様々な問題を解くことができます。まず、問題グラフを作成することから始めます：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "\n", + "n = 4\n", + "G = nx.Graph()\n", + "G.add_nodes_from(range(n))\n", + "edge_list = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]\n", + "G.add_weighted_edges_from(edge_list)\n", + "\n", + "colors = [\"red\" for i in range(n)]\n", + "\n", + "\n", + "def draw_graph(G, colors):\n", + " \"\"\"Draws the graph with the chose colors\"\"\"\n", + " layout = nx.shell_layout(G)\n", + " nx.draw_networkx(G, node_color=colors, pos=layout)\n", + " edge_labels = nx.get_edge_attributes(G, \"weight\")\n", + " nx.draw_networkx_edge_labels(G, pos=layout, edge_labels=edge_labels)\n", + "\n", + "\n", + "draw_graph(G, colors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この問題は、2値最適化問題として表現できます。各 $0 \\leq i < n$ （ $n$ はグラフのノード数で、この場合 $n=4$ ）に対して、バイナリー変数 $x_i$ を考えます。この変数は、ノード $i$ が $1$ のラベルを貼ったグループの1つであれば値 $1$ を持ち、 $0$ とラベルを貼った他のグループの1つであれば値 $0$ を持つことになります。また、ノード $i$ からノード $j$ に至るエッジの重みを $w_{ij}$ （隣接行列 $w$の要素 $(i,j)$ ）とします。グラフは無向性なので、 $w_{ij}=w_{ji}$ となります。そうすると、問題は以下のコスト関数を最大化するものとして定式化できます：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C(\\vec{x})\n", + "& =\\sum_{i,j=0}^n w_{ij} x_i(1-x_j)\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n w_{ij} x_i - \\sum_{i,j=0}^n w_{ij} x_ix_j\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n w_{ij} x_i - \\sum_{i=0}^n \\sum_{j=0}^i 2w_{ij} x_ix_j\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "この問題を量子コンピューターで解決するために、コスト関数を観測量の期待値として表現することになります。しかし、Qiskitがネイティブで認める観測量は、固有値が $0$ と $1$ ではなく $1$ と $-1$ であるパウリ演算子で構成されているため、以下のように変数を変更します：\n", + "\n", + "ここで、 $\\vec{x}=(x_0,x_1,\\cdots ,x_{n-1})$ です。隣接行列 $w$ を使って、すべてのエッジの重みに快適にアクセスすることができます。これはコスト関数を求めるのに使われます：\n", + "\n", + "$$\n", + "z_i = 1-2x_i \\rightarrow x_i = \\frac{1-z_i}{2}\n", + "$$\n", + "\n", + "これはつまり、\n", + "\n", + "$$\n", + "\\begin{array}{lcl} x_i=0 & \\rightarrow & z_i=1 \\\\ x_i=1 & \\rightarrow & z_i=-1.\\end{array}\n", + "$$\n", + "\n", + "よって私たちが最大化したいコスト関数は新たに\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "C(\\vec{z})\n", + "& = \\sum_{i,j=0}^n w_{ij} \\bigg(\\frac{1-z_i}{2}\\bigg)\\bigg(1-\\frac{1-z_j}{2}\\bigg)\\\\[1mm]\n", + "\n", + "& = \\sum_{i,j=0}^n \\frac{w_{ij}}{4} - \\sum_{i,j=0}^n \\frac{w_{ij}}{4} z_iz_j\\\\[1mm]\n", + "\n", + "& = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} z_iz_j\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "さらに、量子コンピューターの自然な傾向として、最大値ではなく最小値（通常は最低エネルギー）を見つけるので、 $C(\\vec{z})$ を最大化するのではなく、最小化します：\n", + "\n", + "$$\n", + "-C(\\vec{z}) = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} z_iz_j - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2}\n", + "$$\n", + "\n", + "ここで、最小化するコスト関数があり、その変数は $-1$ と $1$ の値を持つので、パウリ $Z$ について、以下のアナロジーを使えます：\n", + "\n", + "$$\n", + "z_i \\equiv Z_i = \\overbrace{I}^{n-1}\\otimes ... \\otimes \\overbrace{Z}^{i} \\otimes ... \\otimes \\overbrace{I}^{0}\n", + "$$\n", + "\n", + "つまり、変数 $z_i$ は、量子ビット $i$ に作用する $Z$ ゲートに相当することになります：\n", + "\n", + "$$\n", + "Z_i|x_{n-1}\\cdots x_0\\rangle = z_i|x_{n-1}\\cdots x_0\\rangle \\rightarrow \\langle x_{n-1}\\cdots x_0 |Z_i|x_{n-1}\\cdots x_0\\rangle = z_i\n", + "$$\n", + "\n", + "そうすると、考えている観測量は以下のように書くことができ：\n", + "\n", + "$$\n", + "\\hat{H} = \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2} Z_iZ_j\n", + "$$\n", + "\n", + "であり、その後に独立した項を追加する必要があります：\n", + "\n", + "$$\n", + "\\texttt{offset} = - \\sum_{i=0}^n \\sum_{j=0}^i \\frac{w_{ij}}{2}\n", + "$$\n", + "\n", + "この変換は、[`QuadraticProgram.to_ising()`](https://qiskit.org/documentation/optimization/stubs/qiskit_optimization.QuadraticProgram.to_ising.html)で行うことができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_optimization.applications import Maxcut\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "\n", + "w = nx.to_numpy_array(G)\n", + "\n", + "max_cut = Maxcut(w)\n", + "quadratic_program = max_cut.to_quadratic_program()\n", + "observable, offset = quadratic_program.to_ising()\n", + "\n", + "\n", + "def cost_function_max_cut_vqe(theta):\n", + "\n", + " ansatz = TwoLocal(\n", + " observable.num_qubits, \"rx\", reps=1\n", + " )\n", + "\n", + " backend = service.backend(\"ibmq_qasm_simulator\")\n", + "\n", + " # Use estimator to get the expected values corresponding to each ansatz\n", + " estimator = Estimator(session=backend)\n", + " job = estimator.run(ansatz, observable, theta)\n", + " values = job.result().values\n", + "\n", + " return values\n", + "\n", + "\n", + "optimizer = COBYLA()\n", + "\n", + "initial_theta = np.ones(8)\n", + "\n", + "optimizer_result = optimizer.minimize(fun=cost_function_max_cut_vqe, x0=initial_theta)\n", + "\n", + "optimal_parameters = optimizer_result.x\n", + "print(optimal_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この例をアプリケーションで再確認し、オプティマイザーを活用して探索空間を反復する方法を探ります。一般的には、以下のようなことが挙げられます：\n", + "\n", + "- オプティマイザーを活用して最適なパラメーターを見つける。\n", + "- 固有値を求めるための最適なパラメーターをansatzにバインドする。\n", + "- 固有値を我々の問題定義に置き換える。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 測定の戦略：スピード対精度\n", + "\n", + "すでに述べたように、ノイズの多い量子コンピューターを*ブラックボックスのオラクル*として使用しているため、ノイズによって取得される値が非決定的になり、ランダムな揺らぎが生じて、特定のオプティマイザーが提案した解に収束するのを阻害される、あるいは完全に妨害されることがあります。これは、量子的な利点を得るために段階的に進歩していく中で、私たちが対処しなければならない一般的な問題です：\n", + "\n", + "![Advantage](images/cost_function_path_to_quantum_advantage.png)\n", + "\n", + "Qiskit Runtime Primitiveのエラー抑制・エラー緩和オプションを利用してノイズに対応することで、今日の量子コンピューターの実用性を最大化することができます。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "overhead": { + "text": "基本的な実装の場合と比べて、新しい技術によってもたらされる余分なコスト。", + "title": "オーバーヘッド" + } + } + }, + "source": [ + "### エラー抑制\n", + "\n", + "[エラー抑制](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/how_to/error-suppression.html) とは、コンパイル時に回路を最適化して変換し、エラーを最小化するために使用する技術のことです。これは基本的なエラー処理技術であり、通常、ランタイム全体に対する古典的な前処理 [オーバーヘッド](gloss:overhead) をもたらします。このオーバーヘッドには、以下のような量子ハードウェア上で動作するように回路をトランスパイルすることが含まれます：\n", + "\n", + "- 量子システムで実行できるネイティブゲートで回路を表現する。\n", + "- 仮想量子ビットを物理量子ビットにマッピングする。\n", + "- コネクティビティの要件に基づくSWAPの追加。\n", + "- 1Qと2Qのゲートを最適化する。\n", + "- アイドルの量子ビットに動的デカップリングを追加し、デコヒーレンスの影響を防ぐ。\n", + "\n", + "Primitiveは、 optimization_level オプションを設定し、高度なトランスパイルオプションを選択することで、[エラー抑制技術](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/how_to/error-suppression.html) を使用することができます。この後のコースで、結果を改善するためのさまざまな回路構築方法を掘り下げますが、ほとんどの場合、`optimization_level=3` を設定することをお勧めします。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "bias": { + "text": "測定された量に生じる系統的な偏差のことで、通常は誤差によって生じる。", + "title": "偏り" + } + } + }, + "source": [ + "### エラー緩和\n", + "\n", + "[エラー緩和](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/how_to/error-mitigation.html) とは、実行時にデバイスのノイズをモデル化することで、回路エラーを低減させる技術を指します。一般的に、モデルのトレーニングに関連する量子的な前処理オーバーヘッドと、生成されたモデルを使用して生の結果のエラーを軽減するための古典的な後処理オーバーヘッドが発生することになります。\n", + "\n", + "Qiskit Runtime primitiveの `resilience_level` オプションは、エラーに対して構築する回復力の量を指定します。レベルが高いほど、量子サンプリングのオーバーヘッドによる処理時間の長さを犠牲にして、より正確な結果を生成します。レジリエンスレベルは、primitiveのクエリにエラー緩和を適用する際に、コストと精度のトレードオフを設定するために使用されます。\n", + "\n", + "どのようなエラー緩和技術を実装する場合でも、結果の [偏り](gloss:bias) は、以前の、緩和されていない偏りに対して減少することが期待されます。場合によっては、偏りが消えることさえあります。しかし、これには代償が伴います。推定量の偏りを減らすと、統計的なばらつき（つまり分散）が大きくなりますが、これはサンプリングプロセスで回路ごとのショット数をさらに増やすことで説明できます。この場合、偏りを減らすために必要な以上のオーバーヘッドが発生するため、デフォルトではこの動作は行われません。以下の例のように、options.executions.shotsで回路あたりのショット数を調整することで、この操作は、簡単に導入できます。\n", + "\n", + "![Bias Variance Trade-off](images/cost_function_bias_variance_trade_off.png)\n", + "\n", + "このコースでは、これらのエラー緩和モデルを高いレベルで探求し、完全な実装の詳細を必要とせずに、Qiskit Runtime primitiveが実行できるエラー緩和を説明します。\n", + "\n", + "### トワイル読み出しエラー消去法 (T-REx)\n", + "\n", + "トワイル読み出しエラー消去法 (Twirled Readout Error eXtinction, T-REx) は、パウリトワリングとして知られる技法を用いて、量子測定の過程で導入されるノイズを低減します。この手法は、特定の形態のノイズを想定していないため、非常に汎用的で効果的です。\n", + "\n", + "全体のワークフロー:\n", + "\n", + "1. ランダム化されたビットフリップを使用してゼロ状態のデータを取得します (測定前のパウリ X)。\n", + "2. ランダム化されたビットフリップを使用して目的の (ノイズの多い) 状態のデータを取得します (測定前のパウリ X)。\n", + "3. 各データセットの特殊関数を計算し、除算します。\n", + "\n", + " \n", + "\n", + "![TRE-X](images/cost_function_trex_data_collection.png)\n", + "\n", + "以下の例では、 `options.resilience_level = 1`で設定することができます。\n", + "\n", + "### ゼロ・ノイズ外挿\n", + "\n", + "ゼロノイズ外挿（ZNE）は、まず目的の量子状態を準備する回路のノイズを増幅し、いくつかの異なるレベルのノイズの測定値を得て、その測定値を用いてノイズのない結果を推論することで機能します。\n", + "\n", + "全体のワークフロー:\n", + "\n", + "1. いくつかのノイズ要因に対して回路ノイズを増幅する\n", + "2. すべてのノイズ増幅回路を実行する\n", + "3. ゼロノイズ限界に外挿する\n", + "\n", + " \n", + "\n", + "![ZNE](images/cost_function_zne_stages.png)\n", + "\n", + "これは `options.resilience_level = 2` で設定することができます。`noise_factors`, `noise_amplifiers`, `extrapolators` をいろいろと試すことで、さらに最適化できますが、これはこの講義コースの範囲外です。ぜひ、 [ここに書かれているようなオプション](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/how_to/error-mitigation.html#advanced-resilience-options) を使って実験してみてください。\n", + "\n", + "### 確率的エラー・キャンセル\n", + "\n", + "確率的エラー・キャンセル（PEC）は、平均的にノイズ反転チャネルを模倣する回路のコレクションをサンプリングして、目的の計算のノイズを打ち消します。このプロセスは、ノイズキャンセリングヘッドフォンの仕組みに少し似ており、素晴らしい結果をもたらしますが、他の方法ほど一般的ではなく、サンプリングのオーバーヘッドが指数関数的です。\n", + "\n", + "全体のワークフロー:\n", + "\n", + "![PEC](images/cost_function_pec_layers.png)\n", + "\n", + "ステップ 1: パウリトワリング\n", + "\n", + "![PEC Twirling](images/cost_function_pec_pauli_twirling.png)\n", + "\n", + "ステップ 2: レイヤーを繰り返したノイズの学習\n", + "\n", + "![PEC Learning](images/cost_function_pec_learn_layer.png)\n", + "\n", + "ステップ 3: 忠実度の導出 (各ノイズ・チャネルの誤差)\n", + "\n", + "![PEC Fidelity](images/cost_function_pec_curve_fitting.png)\n", + "\n", + "それぞれの方法には、量子計算の回数（時間）と結果の精度のトレードオフという、関連するオーバーヘッドがあります：\n", + "\n", + "$$\n", + "\\begin{array}{c|c|c|c}\n", + " \\text{Methods} & R=1 \\text{, T-REx} & R=2 \\text{, ZNE} & R=3 \\text{, PEC} \\\\[1mm]\n", + " \\hline\n", + " \\text{Assumptions} & \\text{None} & \\text{Ability to scale noise} & \\text{Full knowledge of noise} \\\\[1mm]\n", + " \\text{Qubit overhead} & 1 & 1 & 1 \\\\[1mm]\n", + " \\text{Sampling overhead} & 2 & N_{\\text{noise-factors}} & \\mathcal{O}(e^{\\lambda N_{layers}}) \\\\[1mm]\n", + " \\text{Bias} & 0 & \\mathcal{O}(\\lambda^{N_{\\text{noise-factors}}}) & 0 \\\\[1mm]\n", + "\\end{array}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Qiskit Runtimeの緩和・抑制オプションの使い方\n", + "\n", + "Qiskit Runtimeでエラー緩和と抑制を使用しながら、期待値を計算する方法を紹介します。このプロセスは最適化ループの中で何度も発生しますが、エラー緩和と抑制の設定方法を示すために、この例はシンプルにしています。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit import Parameter, QuantumCircuit\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "theta = Parameter(\"theta\")\n", + "\n", + "qc = QuantumCircuit(2)\n", + "qc.x(1)\n", + "qc.h(0)\n", + "qc.cp(theta, 0, 1)\n", + "qc.h(0)\n", + "observables = SparsePauliOp.from_list([(\"ZZ\", 1)])\n", + "\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## Setup phases\n", + "import numpy as np\n", + "\n", + "phases = np.linspace(0, 2 * np.pi, 50)\n", + "\n", + "# phases need to be expressed as a list of lists in order to work\n", + "individual_phases = [[phase] for phase in phases]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## Create noise model\n", + "from qiskit.providers.fake_provider import FakeManila\n", + "from qiskit_aer.noise import NoiseModel\n", + "from qiskit_ibm_runtime import Options\n", + "\n", + "\n", + "# Make a noise model\n", + "fake_backend = FakeManila()\n", + "noise_model = NoiseModel.from_backend(fake_backend)\n", + "\n", + "# Set options to include the noise model\n", + "options = Options()\n", + "options.simulator = {\n", + " \"noise_model\": noise_model,\n", + " \"basis_gates\": fake_backend.configuration().basis_gates,\n", + " \"coupling_map\": fake_backend.configuration().coupling_map,\n", + " \"seed_simulator\": 42,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "uses-hardware" + ] + }, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import Session, QiskitRuntimeService, Estimator\n", + "\n", + "# Add your token below\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", + "\n", + "noisy_exp_values = []\n", + "exp_values_with_em_es = []\n", + "\n", + "with Session(service=service, backend=\"ibmq_qasm_simulator\") as session:\n", + " # generate noisy results\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(\n", + " circuits=[qc] * len(phases),\n", + " parameter_values=individual_phases,\n", + " observables=[observables] * len(phases),\n", + " shots=1000,\n", + " )\n", + " result = job.result()\n", + " noisy_exp_values = result.values\n", + "\n", + " options.optimization_level = 2\n", + " options.resilience_level = 1\n", + "\n", + " # leverage mitigation and suppression\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(\n", + " circuits=[qc] * len(phases),\n", + " parameter_values=individual_phases,\n", + " observables=[observables] * len(phases),\n", + " shots=1000,\n", + " )\n", + " result = job.result()\n", + " exp_values_with_em_es = result.values\n", + "\n", + " session.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(phases, noisy_exp_values, \"o\", label=\"Noisy\")\n", + "plt.plot(phases, exp_values_with_em_es, \"o\", label=\"Mitigation + Suppression\")\n", + "plt.plot(phases, 2 * np.sin(phases / 2) ** 2 - 1, label=\"Theory\")\n", + "plt.xlabel(\"Phase\")\n", + "plt.ylabel(\"Expectation\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このレッスンでは、コスト関数を作成する方法について学びました：\n", + "\n", + "- コスト関数を作成する\n", + "- [Qiskit Runtime primitives](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/primitives.html) を活用してノイズを軽減・抑制する方法\n", + "- スピードと精度を最適化するための測定戦略の定義方法\n", + "\n", + "このハイレベルな変分の作業は次のようになります：\n", + "\n", + "![Cost Function Circuit](images/cost_function_circuit.png)\n", + "\n", + "このコスト関数は、最適化ループの各繰り返しで実行されます。次のレッスンでは、古典的なオプティマイザーが新しいパラメーターを選択するために、コスト関数の評価をどのように利用するかを探ります。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_bias_variance_trade_off.png b/translations/ja/algorithm-design/cost_function/images/cost_function_bias_variance_trade_off.png new file mode 100644 index 00000000..3c6f94af Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_bias_variance_trade_off.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_circuit.png b/translations/ja/algorithm-design/cost_function/images/cost_function_circuit.png new file mode 100644 index 00000000..cc6ccfcf Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_circuit.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_path_to_quantum_advantage.png b/translations/ja/algorithm-design/cost_function/images/cost_function_path_to_quantum_advantage.png new file mode 100644 index 00000000..fb628f25 Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_path_to_quantum_advantage.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_pec_curve_fitting.png b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_curve_fitting.png new file mode 100644 index 00000000..81dbd902 Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_curve_fitting.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_pec_layers.png b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_layers.png new file mode 100644 index 00000000..18a49ff1 Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_layers.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_pec_learn_layer.png b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_learn_layer.png new file mode 100644 index 00000000..79f1f32e Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_learn_layer.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_pec_pauli_twirling.png b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_pauli_twirling.png new file mode 100644 index 00000000..de67f13d Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_pec_pauli_twirling.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_trex_data_collection.png b/translations/ja/algorithm-design/cost_function/images/cost_function_trex_data_collection.png new file mode 100644 index 00000000..72072be0 Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_trex_data_collection.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_workflow.png b/translations/ja/algorithm-design/cost_function/images/cost_function_workflow.png new file mode 100644 index 00000000..40ccc85e Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_workflow.png differ diff --git a/translations/ja/algorithm-design/cost_function/images/cost_function_zne_stages.png b/translations/ja/algorithm-design/cost_function/images/cost_function_zne_stages.png new file mode 100644 index 00000000..9cb00eb2 Binary files /dev/null and b/translations/ja/algorithm-design/cost_function/images/cost_function_zne_stages.png differ diff --git a/translations/ja/algorithm-design/instances/images/instances_QSR.png b/translations/ja/algorithm-design/instances/images/instances_QSR.png new file mode 100644 index 00000000..f3af04c7 Binary files /dev/null and b/translations/ja/algorithm-design/instances/images/instances_QSR.png differ diff --git a/translations/ja/algorithm-design/instances/images/instances_SSVQE.png b/translations/ja/algorithm-design/instances/images/instances_SSVQE.png new file mode 100644 index 00000000..f9379deb Binary files /dev/null and b/translations/ja/algorithm-design/instances/images/instances_SSVQE.png differ diff --git a/translations/ja/algorithm-design/instances/images/instances_VQD.png b/translations/ja/algorithm-design/instances/images/instances_VQD.png new file mode 100644 index 00000000..ed840988 Binary files /dev/null and b/translations/ja/algorithm-design/instances/images/instances_VQD.png differ diff --git a/translations/ja/algorithm-design/instances/images/instances_VQE.png b/translations/ja/algorithm-design/instances/images/instances_VQE.png new file mode 100644 index 00000000..af8bf7ee Binary files /dev/null and b/translations/ja/algorithm-design/instances/images/instances_VQE.png differ diff --git a/translations/ja/algorithm-design/instances/instances.ipynb b/translations/ja/algorithm-design/instances/instances.ipynb new file mode 100644 index 00000000..acf5465c --- /dev/null +++ b/translations/ja/algorithm-design/instances/instances.ipynb @@ -0,0 +1,455 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instances and extensions" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This chapter will cover several quantum variational algorithms, including:\n", + "\n", + "* [Variational Quantum Eigensolver (VQE)](https://arxiv.org/abs/1304.3061)\n", + "* [Subspace Search VQE (SSVQE)](https://arxiv.org/abs/1810.09434)\n", + "* [Variational Quantum Deflation (VQD)](https://arxiv.org/abs/1805.08138)\n", + "* [Quantum Sampling Regression (QSR)](https://arxiv.org/pdf/2012.02338)\n", + "\n", + "By using these algorithms, we will learn about several design ideas that can be incorporated into custom variational algorithms, such as weights, penalties, oversampling, and undersampling. We encourage you to experiment with these concepts and share your findings with the community." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variational Quantum Eigensolver (VQE)\n", + "\n", + "[VQE](https://arxiv.org/abs/1304.3061) is one of the most widely used variational quantum algorithms, setting up a template for other algorithms to build upon. \n", + "\n", + "![VQE](images/instances_VQE.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VQE's layout is simple:\n", + "\n", + "- Prepare reference operators $U_R$\n", + " - We start from the state $|0\\rangle$ and go to the reference state $|\\rho\\rangle$\n", + "- Apply the variational form $U_V(\\vec\\theta_{i,j})$ to create an ansatz $U_A(\\vec\\theta_{i,j})$\n", + " - We go from the state $|\\rho\\rangle$ to $U_V(\\vec\\theta_{i,j})|\\rho\\rangle = |\\psi(\\vec\\theta_{i,j})\\rangle$\n", + "- Bootstrap at $i=0$ if we have a similar problem (typically found via classical simulation or sampling)\n", + " - Each optimizer will be bootstrapped differently, resulting in an initial set of parameter vectors $\\Theta_0 := \\\\{ {\\vec\\theta_{0,j} | j \\in \\mathcal{J}_\\text{opt}^0} \\\\}$ (e.g., from an initial point $\\vec\\theta_0$).\n", + "- Evaluate the cost function $C(\\vec\\theta_{i,j}) := \\langle \\psi(\\vec{\\theta}) | \\hat{H} | \\psi(\\vec{\\theta})\\rangle$ for all prepared states on a quantum computer.\n", + "- Use a classical optimizer to select the next set of parameters $\\Theta_{i+1}$.\n", + "- Repeat the process until convergence is reached.\n", + "\n", + "This is a simple classical optimization loop where we evaluate the cost function. Some optimizers may require multiple evaluations to calculate a gradient, determine the next iteration, or assess convergence.\n", + "\n", + "Here's the example for the following observable:\n", + "\n", + "$$\n", + "\\hat{O}_1 = 2 II - 2 XX + 3 YY - 3 ZZ,\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "uses-hardware" + ] + }, + "outputs": [], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit import QuantumCircuit\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", + "import numpy as np\n", + "\n", + "# Add your token below\n", + "service = QiskitRuntimeService(\n", + " channel=\"ibm_quantum\",\n", + ")\n", + "\n", + "def cost_function_vqe(theta):\n", + " observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])\n", + " reference_circuit = QuantumCircuit(2)\n", + " reference_circuit.x(0)\n", + "\n", + " variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + " )\n", + " ansatz = reference_circuit.compose(variational_form)\n", + "\n", + " backend = service.backend(\"ibmq_qasm_simulator\")\n", + " \n", + " # Use estimator to get the expected values corresponding to each ansatz\n", + " estimator = Estimator(session=backend)\n", + " job = estimator.run(ansatz, observable, theta)\n", + " values = job.result().values\n", + "\n", + " return values" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use this cost function to calculate optimal parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import COBYLA\n", + "\n", + "initial_theta = np.ones(8)\n", + "optimizer = COBYLA()\n", + "\n", + "optimizer_result = optimizer.minimize(fun=cost_function_vqe, x0=initial_theta)\n", + "\n", + "optimal_parameters = optimizer_result.x\n", + "print(optimal_parameters)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can use our optimal parameters to calculate our minimum eigenvalues:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])\n", + "reference_circuit = QuantumCircuit(2)\n", + "reference_circuit.x(0)\n", + "\n", + "variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + ")\n", + "ansatz = reference_circuit.compose(variational_form)\n", + "solution = ansatz.bind_parameters(optimal_parameters)\n", + "\n", + "backend = service.backend(\"ibmq_qasm_simulator\")\n", + "estimator = Estimator(session=backend)\n", + "job = estimator.run(solution, observable)\n", + "values = job.result().values\n", + "\n", + "experimental_min_eigenvalue = values[0]\n", + "print(experimental_min_eigenvalue)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Subspace Search VQE (SSVQE)\n", + "\n", + "[SSVQE](https://arxiv.org/abs/1810.09434) is a variant of VQE that allows obtaining the first $k$ eigenvalues of an observable $\\hat{H}$ with eigenvalues {$\\lambda_0, \\lambda_1,...,\\lambda_{N-1}$}, where $N\\geq k$. Without loss of generality, we assume that $\\lambda_0<\\lambda_1<...<\\lambda_{N-1}$. SSQVE introduces a new idea by adding weights to help prioritize optimizing for the term with the largest weight.\n", + "\n", + "![SSVQE](images/instances_SSVQE.png)\n", + "\n", + "To implement this algorithm, we need $k$ mutually orthogonal reference states `{latex} \\{ |\\rho_j\\rangle \\}_{j=0}^{k-1}`, meaning $\\langle \\rho_j | \\rho_l \\rangle = \\delta_{jl}$ for $j,lw_l$, and $U_V(\\vec{\\theta})$ is the user-defined variational form.\n", + "\n", + "The SSVQE algorithm relies on the fact that eigenstates corresponding to different eigenvalues are mutually orthogonal. Specifically, the inner product of $U_V(\\vec{\\theta})|\\rho_j\\rangle$ and $U_V(\\vec{\\theta})|\\rho_l\\rangle$ can be expressed as:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle \\rho_j | U_{V}^{\\dagger}(\\vec{\\theta})U_{V}(\\vec{\\theta})|\\rho_l \\rangle\n", + "\n", + "& = \\langle \\rho_j | I |\\rho_l \\rangle \\\\[1mm]\n", + "\n", + "& = \\langle \\rho_j | \\rho_l \\rangle \\\\[1mm]\n", + "\n", + "& = \\delta_{jl}\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "The first equality holds because $U_{V}(\\vec{\\theta})$ is a quantum operator and is therefore unitary. The last equality holds because of the orthogonality of the reference states $|\\rho_j\\rangle$. The fact that orthogonality is preserved through unitary transformations is deeply related to the principle of conservation of information, as expressed in quantum information science. Under this view, non-unitary transformations represent processes where information is either lost or injected.\n", + "\n", + "Weights $w_j$ help ensure that all the states are eigenstates. If the weights are sufficiently different, the term with the largest weight (i.e., $w_0$) will be given priority during optimization over the others. As a result, the resulting state $U_{V}(\\vec{\\theta})|\\rho_0 \\rangle$ will become the eigenstate corresponding to $\\lambda_0$. Because `{latex} \\{ U_{V}(\\vec{\\theta})|\\rho_j\\rangle \\}_{j=0}^{k-1}` are mutually orthogonal, the remaining states will be orthogonal to it and, therefore, contained in the subspace corresponding to the eigenvalues {$\\lambda_1,...,\\lambda_{N-1}$}.\n", + "\n", + "Applying the same argument to the rest of the terms, the next priority would then be the term with weight $w_1$, so $U_{V}(\\vec{\\theta})|\\rho_1 \\rangle$ would be the eigenstate corresponding to $\\lambda_1$, and the other terms would be contained in the eigenspace of {$\\lambda_2,...,\\lambda_{N-1}$}.\n", + "\n", + "By reasoning inductively, we deduce that $U_{V}(\\vec{\\theta})|\\rho_j \\rangle$ will be an approximate eigenstate of $\\lambda_j$ for $0\\leq j < k$.\n", + "\n", + "SSVQE's can be summarized as follows:\n", + "\n", + "- Prepare several reference states by applying a unitary U_R to k different computational basis states\n", + " - This algorithm requires the usage of $k$ mutually orthogonal reference states `{latex} \\{ |\\rho_j\\rangle \\}_{j=0}^{k-1}`, such that $\\langle \\rho_j | \\rho_l \\rangle = \\delta_{jl}$ for $j,l \\lambda_0$, instead of minimizing the cost function $C_0(\\vec{\\theta}) := \\langle \\psi(\\vec{\\theta}) | \\hat{H} | \\psi(\\vec{\\theta})\\rangle$, we optimize:\n", + "\n", + "$$\n", + "C_1(\\vec{\\theta}) := \n", + "C_0(\\vec{\\theta})+ \\beta_0 |\\langle \\psi(\\vec{\\theta})| \\psi(\\vec{\\theta^0})\\rangle |^2 \n", + "$$\n", + "\n", + "The positive value $\\beta_0$ should ideally be greater than $\\lambda_1-\\lambda_0$. \n", + "\n", + "This introduces a new cost function that can be viewed as a constrained problem, where we minimize $C_\\text{VQE}(\\vec{\\theta}) = \\langle \\psi(\\vec{\\theta}) | \\hat{H} | \\psi(\\vec{\\theta})\\rangle$ subject to the constraint that the state must be orthogonal to the previously obtained $|\\psi(\\vec{\\theta^0})\\rangle$, with $\\beta_0$ acting as a penalty term if the constraint is not satisfied.\n", + "\n", + "Alternatively, this new problem can be interpreted as running VQE on the new observable:\n", + "\n", + "$$\n", + "\\hat{H_1} := \\hat{H} + \\beta_0 |\\psi(\\vec{\\theta^0})\\rangle \\langle \\psi(\\vec{\\theta^0})|\n", + "\\quad \\Rightarrow \\quad \n", + "C_1(\\vec{\\theta}) = \\langle \\psi(\\vec{\\theta}) | \\hat{H_1} | \\psi(\\vec{\\theta})\\rangle,\n", + "$$\n", + "\n", + "Assuming that the solution to the new problem is $|\\psi(\\vec{\\theta^1})\\rangle$, the expected value of $\\hat{H}$ (not $\\hat{H_1}$) should be $ \\langle \\psi(\\vec{\\theta^1}) | \\hat{H} | \\psi(\\vec{\\theta^1})\\rangle = \\lambda_1$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To obtain the third eigenvalue $\\lambda_2$, the cost function to optimize is:\n", + "\n", + "$$\n", + "C_2(\\vec{\\theta}) := \n", + "C_1(\\vec{\\theta}) + \\beta_1 |\\langle \\psi(\\vec{\\theta})| \\psi(\\vec{\\theta^1})\\rangle |^2 \n", + "$$\n", + "\n", + "where $\\beta_1$ is a positive constant large enough to enforce orthogonality of the solution state to both $|\\psi(\\vec{\\theta^0})\\rangle$ and $|\\psi(\\vec{\\theta^1})\\rangle$. This penalizes states in the search space that do not meet this requirement, effectively restricting the search space. Thus, the optimal solution of the new problem should be the eigenstate corresponding to $\\lambda_2$.\n", + "\n", + "Like the previous case, this new problem can also be interpreted as VQE with the observable:\n", + "\n", + "$$\n", + "\\hat{H_2} := \\hat{H_1} + \\beta_1 |\\psi(\\vec{\\theta^1})\\rangle \\langle \\psi(\\vec{\\theta^1})|\n", + "\\quad \\Rightarrow \\quad \n", + "C_2(\\vec{\\theta}) = \\langle \\psi(\\vec{\\theta}) | \\hat{H_2} | \\psi(\\vec{\\theta})\\rangle.\n", + "$$\n", + "\n", + "If the solution to this new problem is $|\\psi(\\vec{\\theta^2})\\rangle$, the expected value of $\\hat{H}$ (not $\\hat{H_2}$) should be $ \\langle \\psi(\\vec{\\theta^2}) | \\hat{H} | \\psi(\\vec{\\theta^2})\\rangle = \\lambda_2$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Analogously, to obtain the $k$-th eigenvalue $\\lambda_{k-1}$, you would minimize the cost function:\n", + "\n", + "$$\n", + "C_{k-1}(\\vec{\\theta}) := \n", + "C_{k-2}(\\vec{\\theta}) + \\beta_{k-2} |\\langle \\psi(\\vec{\\theta})| \\psi(\\vec{\\theta^{k-2}})\\rangle |^2,\n", + "$$\n", + "\n", + "Remember that we defined $\\vec{\\theta^j}$ such that $\\langle \\psi(\\vec{\\theta^j}) | \\hat{H} | \\psi(\\vec{\\theta^j})\\rangle = \\lambda_j, \\forall jRead more.", + "title": "最小値" + } + } + }, + "source": [ + "## 勾配ありと勾配なしのオプティマイザー\n", + "\n", + "### 勾配あり\n", + "\n", + "コスト関数 $C(\\vec\\theta)$ において、初期点から関数 $\\vec{\\nabla} C(\\vec\\theta)$ の勾配にアクセスできる場合、関数を最小化する最も簡単な方法は、パラメータを関数の最急降下の方向に更新することです。 つまり、パラメータを $\\vec\\theta_{n+1} = \\vec\\theta_n - \\eta \\vec{\\nabla} C(\\vec\\theta)$ として更新します。ここで、 $\\eta$ は学習率 (更新のサイズを制御する小さな正の[ハイパーパラメータ](gloss:hyperparameter) ) です。 これをコスト関数の極小値 $C({\\vec\\theta^*})$ に収束するまで続けます。[`qiskit.algorithms`](https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.html) は、勾配を計算するためのいくつかの異なる方法を提供します。詳細については、[こちら](https://learn.qiskit.org/course/machine-learning/training-quantum-circuits#training-2-0)をご覧ください。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit import QuantumCircuit\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", + "import numpy as np\n", + "\n", + "# Add your token below\n", + "service = QiskitRuntimeService(\n", + " channel=\"ibm_quantum\",\n", + ")\n", + "\n", + "def cost_function_vqe(theta):\n", + " observable = SparsePauliOp.from_list([(\"II\", 2), (\"XX\", -2), (\"YY\", 3), (\"ZZ\", -3)])\n", + " reference_circuit = QuantumCircuit(2)\n", + " reference_circuit.x(0)\n", + "\n", + " variational_form = TwoLocal(\n", + " 2,\n", + " rotation_blocks=[\"rz\", \"ry\"],\n", + " entanglement_blocks=\"cx\",\n", + " entanglement=\"linear\",\n", + " reps=1,\n", + " )\n", + " ansatz = reference_circuit.compose(variational_form)\n", + "\n", + " backend = service.backend(\"ibmq_qasm_simulator\")\n", + " \n", + " # Use estimator to get the expected values corresponding to each ansatz\n", + " estimator = Estimator(session=backend)\n", + " job = estimator.run(ansatz, observable, theta)\n", + " values = job.result().values\n", + "\n", + " return values" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "このコスト関数とオプティマイザーを使って、最適なパラメーターを算出することができます" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit.algorithms.optimizers import SPSA\n", + "\n", + "initial_theta = np.ones(8)\n", + "optimizer = SPSA()\n", + "\n", + "optimizer_result = optimizer.minimize(fun=cost_function_vqe, x0=initial_theta)\n", + "\n", + "optimal_parameters = optimizer_result.x\n", + "print(optimal_parameters)" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "このタイプの最適化の主な欠点は、収束速度が非常に遅くなることと、最適解を達成する保証がないことです。\n", + "\n", + "![theta に対する f(theta) のグラフ。複数の点は、曲線の最小値を見つける勾配降下法アルゴリズムのさまざまな状態を示します。](images/optimization_gradient_descent.png)\n", + "\n", + "### 勾配なし\n", + "\n", + "勾配を必要としない最適化アルゴリズムは、勾配情報を必要としないため、勾配の計算が困難であったり、コストがかかったり、ノイズが多すぎたりする場合に有効です。また、勾配を利用した手法が局所最適値に収束する傾向があるのに対して、大域最適値を見つける上でより頑健である傾向があります。ここでは、勾配なしオプティマイザーが不毛な台地を回避するのに役立ついくつかの例を紹介します。しかし、勾配なし手法は、特に高次元の探索空間を持つ問題に対してより高い計算リソースを必要とします。\n", + "\n", + "ここでは、代わりに [`COBYLA`](https://qiskit.org/documentation/stubs/qiskit.algorithms.optimizers.COBYLA.html#qiskit.algorithms.optimizers.COBYLA) オプティマイザーを使用する例を紹介します：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit.algorithms.optimizers import COBYLA\n", + "\n", + "initial_theta = np.ones(8)\n", + "optimizer = COBYLA()\n", + "\n", + "optimizer_result = optimizer.minimize(fun=cost_function_vqe, x0=initial_theta)\n", + "\n", + "optimal_parameters = optimizer_result.x\n", + "print(optimal_parameters)" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + "gloss": { + "barren-plateaus": { + "text": "パラメータ化された量子回路の勾配が量子ビット数に対して指数関数的に小さくなると、最適化が難しくなり、最適化計算が不能になる可能性があります。", + "title": "不毛な台地" + } + } + }, + "source": [ + "## 不毛な台地\n", + "\n", + "実際、コストの起伏は、下の例のように丘と谷のように非常に複雑になることがあります。最適化手法は、黒い点と線で示されるように、コストの起伏をナビゲートし、最小値を探します。3つの探索のうち2つは、グローバルな最小値ではなく、ローカルな最小値で終わっていることがわかります。\n", + "\n", + "![コストの起伏](images/optimization_loss_landscape.png)\n", + "\n", + "最適化手法の種類にかかわらず、コストの起伏が比較的平坦である場合、その手法が適切な探索方向を決定することは困難な場合があります。このようなシナリオは[不毛な台地](gloss:barren-plateaus)と呼ばれ、コストの起伏が徐々に平坦にります（したがって、最小値への方向性を決定するのがより困難になります）。パラメータ化された幅広い量子回路において、合理的な方向に沿った勾配が一定の精度でゼロでない確率は、量子ビットの数が増えるにつれて指数関数的に減少することが分かっています。\n", + "\n", + "![Barren Plateaus](images/optimization_barren_plateaus.png)\n", + "\n", + "この分野はまだ活発な研究が行われていますが、最適化性能を向上させるためのいくつかの推奨事項があります：\n", + "\n", + "- **ブートストラップ** は、最適化ループが勾配が小さいパラメータ空間で立ち往生するのを避けるのに役立ちます。\n", + "- **ハードウェア効率の良いansatzの実験**: ブラックボックスオラクルとしてノイズの多い量子系を使用しているため、その評価の質はオプティマイザーの性能に影響を与えることがあります。[`EfficientSU2`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.EfficientSU2.html) のようなハードウェア効率の良いansatzを使用することで、指数関数的に小さな勾配が発生することを回避できる可能性があります。\n", + "- **エラー抑制とエラー緩和の実験**: Qiskit Runtime Primitiveは、様々な `optimization_level`と `resilience_setting` をそれぞれ実験するためのシンプルなインターフェースを提供します。これにより、ノイズの影響を軽減し、最適化プロセスをより効率的に行うことができます。\n", + "- **勾配なしオプティマイザーを使った実験**: `COBYLA`のようなオプティマイザーは、勾配ベースの最適化アルゴリズムとは異なり、勾配情報に頼らずにパラメータを最適化するため、不毛な台地の影響を受けにくいです。" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "このレッスンで、あなたは最適化ループを定義する方法を学びました：\n", + "\n", + "- 最適化ループをブートストラップする。\n", + "- ローカルオプティマイザーとグローバルオプティマイザーを使い分けながら、トレードオフを理解する。\n", + "- 不毛の台地とそれを避ける方法を探る\n", + "\n", + "ハイレベルの変分ワークロードは完了です：\n", + "\n", + "![最適化回路](images/optimization_circuit.png)\n", + "\n", + "次に、このフレームワークを意識して、具体的な変分アルゴリズムを探っていきます。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/reference/images/reference_circuit.png b/translations/ja/algorithm-design/reference/images/reference_circuit.png new file mode 100644 index 00000000..e11ef33a Binary files /dev/null and b/translations/ja/algorithm-design/reference/images/reference_circuit.png differ diff --git a/translations/ja/algorithm-design/reference/images/reference_workflow.png b/translations/ja/algorithm-design/reference/images/reference_workflow.png new file mode 100644 index 00000000..ce32b9e0 Binary files /dev/null and b/translations/ja/algorithm-design/reference/images/reference_workflow.png differ diff --git a/translations/ja/algorithm-design/reference/reference.ipynb b/translations/ja/algorithm-design/reference/reference.ipynb new file mode 100644 index 00000000..59383800 --- /dev/null +++ b/translations/ja/algorithm-design/reference/reference.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + "gloss": { + "reference": { + "text": "問題の初期状態、決まった開始状態。通常 $|0\\rangle$ を指しますが、問題を適切に表現する様々な状態に設定することができます。", + "title": "参照状態" + } + } + }, + "source": [ + "## 参照状態\n", + "\n", + "このレッスンでは、変分アルゴリズムをより速く収束させるために、参照状態で系を初期化する方法について学びます。まず、 [*参照状態*](gloss:reference) を手動で構築する方法を学び、次に変分アルゴリズムで使用可能ないくつかの標準的な選択肢を探ります。\n", + "\n", + "![Reference Workflow](images/reference_workflow.png)" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## デフォルト状態\n", + "\n", + "*参照状態* とは、問題に対する最初の固定開始状態を意味します。参照状態を準備するために、量子回路の開始時に適切なパラメータ化されていないユニタリー回路 $U_R$ を適用し、 $|\\rho\\rangle = U_R |0\\rangle$ となるようにする必要があります。既存の最適解からの推測やデータ点がある場合、それを出発点として使用すると変分アルゴリズムが早く収束する可能性があります。\n", + "\n", + "最も単純な参照状態はデフォルト状態であり、 $n$ 量子ビット回路の開始状態 $|0\\rangle^{\\otimes n}$ を使用します。 デフォルト状態の場合、ユニタリー演算子 $U_R \\equiv I$ が使われます。その単純さゆえに、デフォルト状態は多くのシナリオで使用される有効な参照状態です。" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## 古典的な参照状態\n", + "\n", + "$3$ 量子ビット系で、デフォルトの状態 $|000\\rangle$ の代わりに状態 $|001\\rangle$ で始めたいとします。これは純粋に古典的な参照状態の例で、これを構築するには、(Qiskitの量子ビット順序に従って)量子ビット $0$ に [X ゲート](https://qiskit.org/documentation/stubs/qiskit.circuit.library.XGate.html) を適用するだけで、 $|001\\rangle = X_0 |000\\rangle$ となります。\n", + "\n", + "この場合、ユニタリー演算子は $U_R \\equiv X_0$ となり、参照状態 $|\\rho\\rangle \\equiv |001\\rangle$ を作ります。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "qc = QuantumCircuit(3)\n", + "qc.x(0)\n", + "\n", + "qc.draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## 量子的な参照状態\n", + "\n", + "例えば、 $\\frac{1}{\\sqrt{2}}(|100\\rangle+|111\\rangle)$ のような重ね合わせやエンタングルメントを含むより複雑な状態から始めたいとします。\n", + "\n", + "この状態を $|000\\rangle$ から得る方法の一つに、量子ビット $0$ に対して [アダマールゲート](https://qiskit.org/documentation/stubs/qiskit.circuit.library.HGate.html)（ $H_0$ ）、量子ビット $0$ を制御量子ビット、量子ビット $1$ をターゲット量子ビットとする [CNOT（CX）](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html)ゲート（ $CNOT_{01}$ ）、最後に量子ビット $2$ に対する $X$ ゲート（ $X_2$ ）を適用する方法があります。\n", + "\n", + "このとき、ユニタリー演算子は $U_{R} \\equiv X_2CNOT_{01}H_0|000\\rangle$ 、参照状態は $|\\rho\\rangle \\equiv \\frac{1}{\\sqrt{2}}(|100\\rangle+|111\\rangle)$ です。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "qc = QuantumCircuit(3)\n", + "qc.h(0)\n", + "qc.cx(0, 1)\n", + "qc.x(2)\n", + "\n", + "qc.draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## テンプレート回路を用いた参照状態の構築\n", + "\n", + "また、複数の調整可能なパラメータやエンタングルメントを簡単に表現できる [`TwoLocal`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.TwoLocal.html) など、様々なテンプレート回路を利用することができます。これらのテンプレート回路については、次回のレッスンで詳しく説明しますが、パラメータをバインドした *場合* 、参照状態に利用することができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "from math import pi\n", + "\n", + "reference_circuit = TwoLocal(2, \"rx\", \"cz\", entanglement=\"linear\", reps=1)\n", + "theta_list = [pi / 2, pi / 3, pi / 3, pi / 2]\n", + "\n", + "reference_circuit = reference_circuit.bind_parameters(theta_list)\n", + "\n", + "reference_circuit.decompose().draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "## アプリケーション固有の参照状態" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "### 量子化学\n", + "\n", + "量子化学では、 *Hartree-Fock* 状態は原子や分子の基底状態の近似値です。正確な基底状態を求める変分アルゴリズムを作成することが目的であれば、この既知の古典的近似を参照状態として使用することで、アルゴリズムの収束を早くすることができます。\n", + "\n", + "この例では、2つの空間軌道と2つの電子（1つのアルファ・スピン、1つのベータ・スピン）を持つ問題に対して、次のように電子構造の問題を生成することができます。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit_nature.second_q.circuit.library import HartreeFock\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "\n", + "num_spatial_orbitals = 2\n", + "num_particles = (1, 1)\n", + "\n", + "mapper = JordanWignerMapper()\n", + "\n", + "h2_reference_state = HartreeFock(\n", + " num_spatial_orbitals=num_spatial_orbitals,\n", + " num_particles=num_particles,\n", + " qubit_mapper=mapper,\n", + ")\n", + "\n", + "h2_reference_state.decompose().draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "また、水素化リチウム（LiH）のような特定の分子を構成することも可能です。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit_nature.second_q.drivers import PySCFDriver\n", + "from qiskit_nature.second_q.circuit.library import HartreeFock\n", + "from qiskit_nature.second_q.mappers import JordanWignerMapper\n", + "from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo\n", + "\n", + "molecule = MoleculeInfo(\n", + " # Coordinates in Angstrom\n", + " symbols=[\"Li\", \"H\"],\n", + " coords=([0.0, 0.0, 0.0], [0.2, 0.0, 0.0]),\n", + " multiplicity=1, # = 2*spin + 1\n", + " charge=0,\n", + ")\n", + "\n", + "driver = PySCFDriver.from_molecule(molecule)\n", + "LiH_problem = driver.run()\n", + "\n", + "mapper = JordanWignerMapper()\n", + "LiH_reference_state = HartreeFock(\n", + " num_spatial_orbitals=LiH_problem.num_spatial_orbitals,\n", + " num_particles=LiH_problem.num_particles,\n", + " qubit_mapper=mapper,\n", + ")\n", + "\n", + "LiH_reference_state.decompose().draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "### 量子機械学習\n", + "\n", + "[変分量子分類器（VQC）](https://learn.qiskit.org/course/machine-learning/variational-classification) の文脈では、訓練データは、 *特徴量マップ* として知られるパラメータ化された回路で量子状態に符号化され、各パラメータの値は訓練データセットのデータ点を表します。 [ZZFeatureMap](https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html) は、この特徴量マップにデータ点($x$) を渡すパラメータ化回路の一種です。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + }, + "outputs": [ + + ], + "source": [ + "from qiskit.circuit.library import ZZFeatureMap\n", + "\n", + "data = [0.1, 0.2]\n", + "\n", + "zz_feature_map_reference = ZZFeatureMap(feature_dimension=2, reps=2)\n", + "zz_feature_map_reference = zz_feature_map_reference.bind_parameters(data)\n", + "zz_feature_map_reference.decompose().draw(\"mpl\")" + ] + }, + { + "attachments": { + }, + "cell_type": "markdown", + "metadata": { + }, + "source": [ + "このレッスンで、あなたは、以下を使ってシステムを初期化する方法を学びました：\n", + "\n", + "- デフォルトの参照状態\n", + "- 古典的な参照状態\n", + "- 量子的な参照状態\n", + "- アプリケーション固有の参照状態\n", + "\n", + "このハイレベルな変分ワークロードは次のようになります。\n", + "\n", + "![Reference Circuit](images/reference_circuit.png)\n", + "\n", + "参照状態は固定された最初の出発点であるのに対し、 *変分形式* を使って、変分アルゴリズムが探索するためのパラメータ化された状態の集合を表す *ansatz* を定義することができます。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/algorithm-design/variational/images/variational_workflow.png b/translations/ja/algorithm-design/variational/images/variational_workflow.png new file mode 100644 index 00000000..96c92448 Binary files /dev/null and b/translations/ja/algorithm-design/variational/images/variational_workflow.png differ diff --git a/translations/ja/algorithm-design/variational/variational.ipynb b/translations/ja/algorithm-design/variational/variational.ipynb new file mode 100644 index 00000000..d0601a92 --- /dev/null +++ b/translations/ja/algorithm-design/variational/variational.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 変分アルゴリズム" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "advantage": { + "text": "特定の計算問題を古典コンピューターよりも高速に解決する量子コンピューターの能力の実用的なデモンストレーション。", + "title": "量子優位性" + }, + "converge": { + "text": "アルゴリズムをさらに繰り返したり修正したりしても、ソリューションが大幅に改善または変更されない、安定した最適解に到達すること。", + "title": "収束" + } + } + }, + "source": [ + "このコースでは、変分アルゴリズムの詳細と、量子力学の変分定理に基づく近い将来のハイブリッド量子-古典アルゴリズムについて説明します。これらのアルゴリズムは、今日のフォールトトレラントでない量子コンピューターによって提供されるユーティリティを活用できるため、[量子優位性](gloss:advantage)を達成するための理想的な候補になります。\n", + "\n", + "このコースでは次のことを学びます。\n", + "\n", + "- 変分アルゴリズム設計ワークフローの各ステップ\n", + "- 各ステップに関連するトレードオフ\n", + "- [Qiskit Runtimeプリミティブ](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/primitives.html)を使用して速度と精度を最適化する方法\n", + "\n", + "このコースは、研究者や開発者が量子コンピューターの有用性を探求するための出発点となることを意図していますが、量子コンピューティング全般の理論的・基礎的な知識は[量子情報と計算の基礎](https://qiskit.org/learn/course/basics-quantum-information/)( [YouTubeシリーズ](https://www.youtube.com/playlist?list=PLOFEBzvs-VvqKKMXX4vbi4EB1uaErFMSO)としても視聴可能）を自由に探検してみてください。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 簡素化されたハイブリッドワークフロー\n", + "\n", + "![Variational Flow](images/variational_workflow.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "cost_function": { + "text": "モデルまたはアルゴリズムの予測出力と実際の出力との差を測定するために使用される数学関数で、最適化によってこの差を最小限に抑えることを目的としています。", + "title": "コスト関数" + } + } + }, + "source": [ + "変分アルゴリズムには、アルゴリズム、ソフトウェア、およびハードウェアの進歩に基づいて組み合わせて最適化できるいくつかのモジュラーコンポーネントが含まれています。これには、一連のパラメーターを使用して特定の問題を記述する*コスト関数*、これらのパラメーターを使用して探索空間を表現するための*ansatz* 、および探索空間を繰り返し探索するための*オプティマイザー*が含まれます。各反復中に、オプティマイザーは現在のパラメーターを使用してコスト関数を評価し、最適解に[収束](gloss:converge)するまで次の反復のパラメーターを選択します。この種のアルゴリズムがハイブリッドな点は、コスト関数が量子リソースを使用して評価され、古典リソースによって最適化されることに由来します。\n", + "\n", + "1. **問題の初期化**: 変分アルゴリズムは、量子コンピューターを*初期状態* $|0\\rangle$ に初期化することから始まり、次にそれを望みの (パラメーター化されていない) 状態 $|\\rho\\rangle$ に変換します。これを*参照状態 *と呼びます。\n", + "\n", + " この変換は、 $U_R|0\\rangle = |\\rho\\rangle$ のように、既定の状態にユニタリ参照演算子 $U_R$ を適用することで表現されます。\n", + "\n", + "2. **ansatzの準備**: 初期状態 $|0\\rangle$ からターゲット状態 $|\\psi(\\vec\\theta)\\rangle$ への反復最適化を開始するには、*変分形式* $U_V(\\vec\\theta)$ を定義する必要があります。変分アルゴリズムが探索するパラメータ化された状態のコレクションを表します。\n", + "\n", + " 参照状態と変分形式の特定の組み合わせをansatzと呼びます。例えば $U_A(\\vec\\theta) := U_V(\\vec\\theta) U_R$ です。
ansatzは最終的に、初期状態 $|0\\rangle$ をターゲット状態 $|\\psi(\\vec\\theta)\\rangle$ に変換できるパラメータ化された量子回路の形を取ります。\n", + "\n", + " 全体として次のようになります。\n", + "\n", + " $$\n", + " \\begin{aligned}\n", + " |0\\rangle \\xrightarrow{U_R} U_R|0\\rangle\n", + "\n", + " & = |\\rho\\rangle \\xrightarrow{U_V(\\vec{\\theta})} U_A(\\vec{\\theta})|0\\rangle \\\\[1mm]\n", + "\n", + " & = U_V(\\vec{\\theta})U_R|0\\rangle \\\\[1mm]\n", + "\n", + " & = U_V(\\vec{\\theta})|\\rho\\rangle \\\\[1mm]\n", + "\n", + " & = |\\psi(\\vec{\\theta})\\rangle \\\\[1mm]\n", + "\n", + " \\end{aligned}\n", + " $$\n", + "\n", + "3. **コスト関数の評価**: 問題を*コスト関数* $C(\\vec\\theta)$ にエンコードし、量子系で実行するパウリ演算子の線形結合として使用できます。これは、エネルギーやスピンなどの物理系に関する情報である可能性がありますが、物理でない問題も同じようにエンコードすることができます。 Qiskit Runtimeプリミティブを活用して、コスト関数を評価しながらエラーの抑制と軽減でノイズに対処できます。\n", + "\n", + "4. **パラメーターの最適化**: 評価結果は古典コンピューターに送られ、そこで古典オプティマイザーが分析し、変分パラメーターの次の値のセットを選択します。既存の最適解がある場合、それを*初期点* $\\vec\\theta_0$ として設定して、最適化を*ブートストラップ*できます。この*初期状態* $|\\psi(\\vec\\theta_0)\\rangle$ を使用すると、オプティマイザーが有効な解をより速く見つけるのに役立ちます。\n", + "\n", + "5. **結果に基づいた ansatz パラメーターの調整と再実行**: 古典オプティマイザーの終端基準が満たされるまでプロセス全体が繰り返され、パラメーター値の最適なセット $\\vec\\theta^ {em1}$ が返されます。そして、この問題の解の状態は、 $|\\psi(\\vec\\theta^ )\\rangle = U_A(\\vec\\theta^*)|0\\rangle$ と提案されます。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 変分定理\n", + "\n", + "変分アルゴリズムの一般的な目標は、特定の観測可能量の最小または最大の固有値を持つ量子状態を見つけることです。ここで使用する重要な洞察は、量子力学の*変分定理*です。詳細に入る前に、その背後にある数学的直感をいくつか調べてみましょう." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "decomposition": { + "text": "行列を固有値と固有ベクトルの和として表現するプロセス。これにより、その特性と振舞いの分析と操作が可能になります。", + "title": "スペクトル分解" + }, + "eigenstate": { + "text": "エネルギーや運動量などの大きさが一定の値を持つ物理系の状態。", + "title": "固有状態" + } + } + }, + "source": [ + "### エネルギーと基底状態の数学的直感\n", + "\n", + "量子力学では、エネルギーは通常*ハミルトニアン*と呼ばれる観測可能量の形で表され、これを $\\hat{\\mathcal{H}}$ で表します。[スペクトル分解](gloss:decomposition)を考えてみましょう :\n", + "\n", + "$$\n", + "\\hat{\\mathcal{H}} = \\sum_{k=0}^{N-1} \\lambda_k |\\phi_k\\rangle \\langle \\phi_k|\n", + "$$\n", + "\n", + "ここで、 $N$ は状態空間の次元、 $\\lambda_{k}$ は $k$ 番目の固有値、または物理的には $k$ 番目のエネルギー準位、 $|\\phi_k\\rangle$ は $\\hat{\\mathcal{H}}|\\phi_k\\rangle = \\lambda_k |\\phi_k\\rangle$ に対応する[固有状態](gloss:eigenstate): (正規化された) 状態 $|\\psi\\rangle$ の系の期待エネルギーは以下のようになります。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle \\psi | \\hat{\\mathcal{H}} | \\psi \\rangle\n", + "\n", + "& = \\langle \\psi |\\bigg(\\sum_{k=0}^{N-1} \\lambda_k |\\phi_k\\rangle \\langle \\phi_k|\\bigg) | \\psi \\rangle \\\\[1mm]\n", + "\n", + "& = \\sum_{k=0}^{N-1} \\lambda_k \\langle \\psi |\\phi_k\\rangle \\langle \\phi_k| \\psi \\rangle \\\\[1mm]\n", + "\n", + "& = \\sum_{k=0}^{N-1} \\lambda_k |\\langle \\psi |\\phi_k\\rangle|^2 \\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "$\\lambda_0\\leq \\lambda_k, \\forall k$ を考慮すると、次のようになります。\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\langle \\psi | \\hat{\\mathcal{H}} | \\psi \\rangle\n", + "\n", + "& = \\sum_{k=0}^{N-1} \\lambda_k |\\langle \\psi |\\phi_k\\rangle|^2 \\\\[1mm]\n", + "\n", + "& \\geq \\sum_{k=0}^{N-1} \\lambda_0 |\\langle \\psi |\\phi_k\\rangle|^2 \\\\[1mm]\n", + "\n", + "& = \\lambda_0 \\sum_{k=0}^{N-1} |\\langle \\psi |\\phi_k\\rangle|^2 \\\\[1mm]\n", + "\n", + "& = \\lambda_0 \\\\[1mm]\n", + "\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "`{latex} \\{ |\\phi_k\\rangle \\}_{k=0}^{N-1}` は正規直交基底であるため、 $|\\phi_{k} \\rangle$ を測定する確率は $p_k = |\\langle \\psi |\\phi_{k} \\rangle |^2$ であり、すべての確率の合計は $\\sum_{k=0}^{N-1} |\\langle \\psi |\\phi_k\\rangle|^2 = \\sum_{k=0}^{N-1}p_k = 1$ となります。要するに、系の期待されるエネルギーは、最小エネルギーまたは基底状態エネルギーよりも高くなります。\n", + "\n", + "$$\n", + "\\langle \\psi | \\hat{\\mathcal{H}} | \\psi \\rangle \\geq \\lambda_0.\n", + "$$\n", + "\n", + "上記の引数は、有効な (正規化された) 量子状態 $|\\psi\\rangle$ に適用されるため、パラメーターベクトル $\\vec\\theta$ に依存するパラメーター化された状態 $|\\psi(\\vec\\theta)\\rangle$ を考慮することは完全に可能です。ここで「変分」の出番です。 $C(\\vec\\theta) := \\langle \\psi(\\vec\\theta)|\\hat{\\mathcal{H}}|\\psi(\\vec\\theta)\\rangle$ で与えられるコスト関数を考えるとそれを最小化したい場合、最小値は常に次を満たします。\n", + "\n", + "$$\n", + "\\min_{\\vec\\theta} C(\\vec\\theta) = \n", + "\\min_{\\vec\\theta} \\langle \\psi(\\vec\\theta)|\\hat{\\mathcal{H}}|\\psi(\\vec\\theta)\\rangle \\geq \\lambda_0.\n", + "$$\n", + "\n", + "$C(\\vec\\theta)$ の最小値は、パラメータ化された状態 $|\\psi(\\vec\\theta)\\rangle$ を使用して $\\lambda_0$ に到達できる最も近い値になり、 $|\\psi(\\vec\\theta^{em0})\\rangle = |\\phi_0\\rangle$ となるパラメータベクトル $\\vec\\theta^{/em0}$ が存在する場合にのみ等号が成り立ちます。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "gloss": { + "expectation": { + "text": "状態の結果の確率によって重み付けされた、特定の状態における量子系の測定値の平均値。", + "title": "期待値" + } + } + }, + "source": [ + "### 量子力学の変分定理\n", + "\n", + "量子系の (正規化された) 状態 $|\\psi\\rangle$ がパラメータベクトル $\\vec\\theta$ に依存する場合、基底状態の最適近似 (つまり、最小固有値 $\\lambda_0$ をとる固有状態 $|\\phi_0\\rangle$) は、ハミルトニアン $\\hat{\\mathcal{H}}$ の[期待値](gloss:expectation)を最小化するものです:\n", + "\n", + "$$\n", + "\\langle \\hat{\\mathcal{H}} \\rangle(\\vec\\theta) := \n", + "\\langle \\psi(\\vec\\theta) |\\hat{\\mathcal{H}}| \\psi(\\vec\\theta) \\rangle \\geq \n", + "\\lambda_0\n", + "$$\n", + "\n", + "変分定理がエネルギー最小値の観点から述べられている理由は、多くの数学的仮定が含まれているためです。\n", + "\n", + "- 物理的な理由から、 $N\\rightarrow\\infty$ であっても、エネルギー $E \\geq \\lambda_0 > -\\infty$ を満たす有限の下限が存在する必要があります。\n", + "- 通常上限は存在しません。\n", + "\n", + "ただし、数学的に言えば、ハミルトニアン $\\hat{\\mathcal{H}}$ についてこれらの仮定を超える特別なことは何もないため、定理は他の観測可能量とその固有状態に一般化できますが、同じ制約に従う場合に限ります。また、有限の上限が存在する場合、下限を上限に交換することにより、固有値を最大化するために同じ数学的議論を行うことができることに注意してください。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このレッスンでは、変分アルゴリズムの概要を学習しました。以降のレッスンでは、各ステップとそれに関連するトレードオフについて詳しく説明します。" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/translations/ja/basics/multiple-systems.ipynb b/translations/ja/basics/multiple-systems.ipynb index 4b8e8a09..f1acc553 100755 --- a/translations/ja/basics/multiple-systems.ipynb +++ b/translations/ja/basics/multiple-systems.ipynb @@ -1158,7 +1158,7 @@ "4 つのベルの状態のすべての集まり\n", "\n", "$$\n", - " \\bigl\\{\\vert \\phi^+ \\rangle, \\vert \\phi^- \\rangle, \\vert \\psi^+ \\rangle, \\vert \\psi^+ \\rangle\\bigr\\}\n", + " \\bigl\\{\\vert \\phi^+ \\rangle, \\vert \\phi^- \\rangle, \\vert \\psi^+ \\rangle, \\vert \\psi^- \\rangle\\bigr\\}\n", "$$\n", "\n", "は、 *ベル基底*として知られています。 2量子ビットの任意の量子状態ベクトル、または実際には 2 ビットの 4 つの古典的な状態に対応する要素を持つ任意の複素ベクトルは、4 つのベル状態の線形結合として表現できます。例えば、次のようになります。\n", @@ -1704,7 +1704,7 @@ "\n", "2つのシステムに注目すると、 $\\mathsf{X}$ が古典状態の集合 $\\Sigma$ を持つシステム、 $\\mathsf{Y}$ が古典状態集合 $\\Gamma$ を持つシステムであれば、合成システムの古典状態の集合 $(\\mathsf{X},\\mathsf{Y})$ は $\\Sigma\\times\\Gamma$ です。 したがって、この合成システムに対して実行可能な演算の集合は、行と列が集合 $\\Sigma\\times\\Gamma$ に対応するように配置されたユニタリー行列で表現されます。この行列の行と列の並びは、システム $(\\mathsf{X},\\mathsf{Y})$ の量子状態ベクトルに用いられる並びと同じです。\n", "\n", - "例えば、 $\\Sigma = \\{1,2,3\\}$ と $\\Gamma = \\{0,1\\}$ とすると、デカルト積 $\\{1,2,3\\}\\times\\{0,1\\}$ の要素の順番は、 $(1,0)$, $(1,1)$, $(2,0)$, $(2,1)$, $(3,0)$, $(3,1)$ が標準であす。
以下は、 $(\\mathsf{X},\\mathsf{Y})$ 上の演算を表すユニタリー行列の例です。\n", + "例えば、 $\\Sigma = \\{1,2,3\\}$ と $\\Gamma = \\{0,1\\}$ とすると、デカルト積 $\\{1,2,3\\}\\times\\{0,1\\}$ の要素の順番は、 $(1,0)$, $(1,1)$, $(2,0)$, $(2,1)$, $(3,0)$, $(3,1)$ が標準です。
以下は、 $(\\mathsf{X},\\mathsf{Y})$ 上の演算を表すユニタリー行列の例です。\n", "\n", "$$\n", "U = \n", @@ -1874,7 +1874,7 @@ "\n", "授業を締めくくるために、複数システムでのユニタリー演算の例を 2 つ見てみましょう。*スワップ演算*から始めます。\n", "\n", - "$\\mathsf{X}$ と $\\mathsf{Y}$ が、同じ古典的な状態セット $\\Sigma$ を共有するシステムであるとします。ペア $(\\mathsf{X},\\mathsf{Y})$ の*スワップ*操作は、2 つのシステムの内容を交換する操作ですが、それ以外の場合はシステムをそのままにしておきます (したがって、$\\mathsf{X}$ は残ります)。左側に、$\\mathsf{Y}$ が右側に残ります)。\n", + "$\\mathsf{X}$ と $\\mathsf{Y}$ が、同じ古典的な状態セット $\\Sigma$ を共有するシステムであるとします。ペア $(\\mathsf{X},\\mathsf{Y})$ の*スワップ*操作は、2 つのシステムの内容を交換する操作ですが、それ以外の場合はシステムをそのままにしておきます (したがって、 $\\mathsf{X}$ は左側に、 $\\mathsf{Y}$ が右側に残ります)。\n", "\n", "この演算を $\\operatorname{SWAP}$ と書き、古典的な状態 $a,b\\in\\Sigma$ のすべての選択に対して、次のように操作します。\n", "\n", @@ -2053,7 +2053,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "以下の別の例では、 $|{-}\\rangle$ および $\\tfrac{1}{\\sqrt{2}}(|0\\rangle + i|1\\rangle)$ 状態を表す状態ベクトルを作成し、合成して、新しい状態ベクトルを作成します。この新しいベクトルを変数`psi`に割り当てます。" + "以下の別の例では、 $|{+}\\rangle$ および $\\tfrac{1}{\\sqrt{2}}(|0\\rangle + i|1\\rangle)$ 状態を表す状態ベクトルを作成し、合成して、新しい状態ベクトルを作成します。この新しいベクトルを変数`psi`に割り当てます。" ] }, { diff --git a/translations/ja/quantum-hardware/error-correction-repetition-code.ipynb b/translations/ja/quantum-hardware/error-correction-repetition-code.ipynb index e8534974..a066fe96 100755 --- a/translations/ja/quantum-hardware/error-correction-repetition-code.ipynb +++ b/translations/ja/quantum-hardware/error-correction-repetition-code.ipynb @@ -157,7 +157,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'000': 992, '001': 6, '010': 18, '100': 8}\n" + "{'001': 6, '100': 10, '010': 11, '000': 997}\n" ] } ], @@ -174,6 +174,20 @@ "print(counts)" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# ...almost all results still come out '000',...\n", + "assert counts['000'] > sum(counts.values())*0.95" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -185,14 +199,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'011': 16, '101': 13, '110': 16, '111': 979}\n" + "{'001': 1, '110': 16, '101': 19, '011': 9, '111': 979}\n" ] } ], @@ -208,6 +222,21 @@ "print(counts)" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# ...number of samples that come out with a majority in the wrong state\n", + "# (0 in this case) is again much less than 10,...\n", + "assert counts.get('000', 0) < 10" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -219,14 +248,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'000': 127, '001': 123, '010': 133, '011': 152, '100': 117, '101': 122, '110': 118, '111': 132}\n" + "{'100': 124, '001': 126, '110': 119, '101': 133, '010': 117, '000': 127, '011': 139, '111': 139}\n" ] } ], @@ -236,6 +265,21 @@ "print(counts)" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# ...all outcomes occur with equal probability, with\n", + "# differences in results being due only to statistical noise.\n", + "assert max(counts.values()) < 200" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -280,17 +324,19 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -298,13 +344,13 @@ "source": [ "from qiskit import QuantumRegister, ClassicalRegister\n", "\n", - "cq = QuantumRegister(2,'code_qubit')\n", - "lq = QuantumRegister(1,'ancilla_qubit')\n", - "sb = ClassicalRegister(1,'syndrome_bit')\n", - "qc = QuantumCircuit(cq,lq,sb)\n", - "qc.cx(cq[0],lq[0])\n", - "qc.cx(cq[1],lq[0])\n", - "qc.measure(lq,sb)\n", + "cq = QuantumRegister(2, 'code_qubit')\n", + "lq = QuantumRegister(1, 'ancilla_qubit')\n", + "sb = ClassicalRegister(1, 'syndrome_bit')\n", + "qc = QuantumCircuit(cq, lq, sb)\n", + "qc.cx(cq[0], lq[0])\n", + "qc.cx(cq[1], lq[0])\n", + "qc.measure(lq, sb)\n", "qc.draw()" ] }, @@ -319,30 +365,32 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 8, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "qc_init = QuantumCircuit(cq)\n", + "qc_init = QuantumCircuit(cq, lq, sb)\n", "\n", - "(qc_init+qc).draw()" + "qc_init.compose(qc).draw()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -354,8 +402,22 @@ } ], "source": [ - "counts = execute( qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()\n", - "print('Results:',counts)" + "counts = execute(qc_init.compose(qc), Aer.get_backend('qasm_simulator')).result().get_counts()\n", + "print('Results:', counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# The outcome, in all cases, is 0.\n", + "assert list(counts.keys()) == ['0']" ] }, { @@ -369,31 +431,33 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 10, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "qc_init = QuantumCircuit(cq)\n", + "qc_init = QuantumCircuit(cq, lq, sb)\n", "qc_init.x(cq)\n", "\n", - "(qc_init+qc).draw()" + "qc_init.compose(qc).draw()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -405,8 +469,22 @@ } ], "source": [ - "counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()\n", - "print('Results:',counts)" + "counts = execute(qc_init.compose(qc), Aer.get_backend('qasm_simulator')).result().get_counts()\n", + "print('Results:', counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# The outcome in this case is also always 0.\n", + "assert list(counts.keys()) == ['0']" ] }, { @@ -418,32 +496,34 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 12, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "qc_init = QuantumCircuit(cq)\n", + "qc_init = QuantumCircuit(cq, lq, sb)\n", "qc_init.h(cq[0])\n", - "qc_init.cx(cq[0],cq[1])\n", + "qc_init.cx(cq[0], cq[1])\n", "\n", - "(qc_init+qc).draw()" + "qc_init.compose(qc).draw()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -455,8 +535,23 @@ } ], "source": [ - "counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()\n", - "print('Results:',counts)" + "counts = execute(qc_init.compose(qc), Aer.get_backend('qasm_simulator')).result().get_counts()\n", + "print('Results:', counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# ...we can expect the same to be true also for\n", + "# any superposition of |00⟩ and |11⟩...\n", + "assert list(counts.keys()) == ['0']" ] }, { @@ -468,33 +563,35 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAADWCAYAAABSSMygAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0aUlEQVR4nO3deVzU1f748dewiSgKjAuymCKaigsK5kqKkmLlkqmphCXupV7z2vKr6EpJLpnXW1R2y7XcMuVmiJp6hfJGxa6IXHIhkYsSYoiCKDC/P+Y7o8OMMNiwOLyfj8fn8XDO53zOeX8mmvec8zmfzyhUKpUKIYQQwoxY1HcAQgghhKlJchNCCGF2JLkJIYQwO5LchBBCmB1JbkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsSHITQghhdiS5CSGEMDuS3IQQQpgdSW5CCCHMjiQ3IYQQZkeSmxBCCLMjyU0IIYTZkeQmhBDC7EhyE0IIYXYkuQkhhDA7ktyEEEKYHUluQgghzI4kNyGEEGZHkpsQQgizI8lNCCGE2ZHkJoQQwuxIchNCCGF2rOo7ANF47U2AnKv107erI0zwrZ++68Nf/5tOalFRvfTd296e9x/uXi99i8ZLkpuoNzlX4WxefUfROKQWFfH91YL6DkOIOiPTkkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsSHITQghhdhpdcktNTUWhUHDgwIH6DqVaubm5KBQKduzYUW3dkydP6pxXcXExy5YtIzk5ucb9FhYWMm/ePNq0aYOdnR2DBw/m+PHjNW5HCCHqS6NLbvHx8QD4+PjUcyTVS0hIAKBfv37V1nVxcSEuLo4RI0YAkJKSQlhYGEU1vHFXpVIxbtw4IiMjWbNmDfv27aNVq1Y89thj95UohRCiPjS6m7jj4+Nxc3OjTZs29R1KtRISEnB0dMTT07PaukqlEqVSqX2dnJyMQqHA29u7Rn1GRUURGxtLdHQ0o0ePBuDRRx/Fy8uLN954g+jo6Bq1J3SpVKBQ1HcUjYO8141bgxy57du3j4CAABwcHLCzs6Nnz55s3LgRUI8s1q9fT9++fbGzs6N9+/YsXryY69ev67RRUVHB6tWr8fT0xNbWlsGDB5Oenk58fDy+vvrPXfryyy8ZPHgwzZo1w9nZmRkzZlBQULMnOlRUVLBmzRo6d+6Mra0tvXv3JjY2locffpg5c+YAUF5ejp2dHWFhYTrHlpWVYWtry6pVq7RliYmJ+Pr6sn37dry9vbGzs8Pb25sjR47o9d2/f38mT54MQM+ePVmwYAEqlYqWLVuiUCgYMGCAUefwzTffoFQqCQwM1JbZ2NgwZcoUDh8+zI0bN2r0npjS18uH8cu/lhtd3lBcKoSvfobXvoKXtsPf9sLBE3D9Zn1Hdm+q27e5PW8B5Z9+plNeHvkvbj/7HKp6/DuoSvYV+PI/8MpOWLId3vkG/p0ON2/Xd2SirjW45BYaGsr48eNxc3Nj48aN7Nmzh7Fjx1JQUEBFRQVBQUEsXbqUSZMmsX//fl5//XU2b97MzJkzddoJCQkhPDycOXPmcODAAQIDAxk7dixpaWl6U5ILFy4kJCSEAQMGEBkZyYoVKzh48CDTpk2rUewhISG88847zJ07lwMHDjB58mSmTp3KuXPntH1mZGRQUlJCnz59dI49deoUpaWlOuWJiYmkp6ezYcMGwsLC2LlzJwDjxo0jOztbW6+8vJyTJ09qj920aRNdu3YlICCAuLg44uLi+OKLL4w6h7S0NLy8vFBU+srbo0cPysrKyMjIqNF70tid/h+siYa4M3c+YAtL4OBJWHMArlyv+vj6orC2xuq1l6mIiqYiOQUA1fksKjZuwfKVpSiaNavfAA1IOA9rD0FiFtwqBxXq93dfMvz9YMP+MiFMr0FNS+7du5fly5ezYcMGQkJCtOWa6bEPP/yQXbt2ERMTg5+fHwD+/v7k5+cTGhrKp59+ioODA9u2bWPLli0cPXqU4cOHa+udOHGCs2fP6iS3HTt2EBERwdatWwkODtaWN23alKlTp5KVlUWHDh2qjX379u1s2bKFmJgYhg4dqu0zKSmJvXv3avtMSkoC0EtumutZmvKcnBwuXbqEn58f3333HZaWlgB4enri5eVFVFQU8+fPB+D06dM6CbNPnz5cuHCBoKAgo0dsGgUFBXTvrv+QWycnJ+1+YZyim7DxeyivUH/QVlZYrN6/dHTDnD5TdHgIi5DnKH9vLYqIdZStXI3FuDFY9OpZ36HpuVwI2+PUU5GG5F2DbXEw179u4xL1p0GN3EJDQ/H399dJbHdbu3YtTz75pDaxaXTq1AmAixcvAvDuu+8yatQobWLT6NatG6C7mOTtt9/Gx8eHqVOnUlZWpt00H/Dnz583KvYVK1YQGBioTWwanp6eWFtb07On+gMhKSkJpVKJu7u7Tr2kpCRcXV1p3bo1oB61AYSHh2sTG0D37t2xsrIiL+/OE4c1ibFv376AenRYXFysfV0TKpVKb9QGGCwTVfvpDNwuN5zYQF2ecxXO/16XUdWMxfhxKB5qT9ncF8HCAovngqs/qB4c/xUq7vVGo36vT/8Pfr9WZyGJetZgklt2djbp6elMmTLF4P6zZ8+SlZXFk08+qbfvwoULALRr146LFy+Snp6uvf50t5ycHNzd3bWLSbKzs8nIyCAxMRFra2udrXfv3gC0bNmy2tgvXrxIWloakyZNMhibl5cXTZo0AdRJrPKoDdQJqvKUpLOzs14iz8/Pp6ysDDc3N51jXVxctOelSYyG+qmOUqk0ODrTlGlGcFVRKBRGbbGxMTWO75dvwvlkjoPO9r/Mmt+mEBsbY3Sc97t9uisWlaqiyjhUKhXPLgiv9VhiYmr+XsP//bfs1RMKC7EIGIHC2rrGbcTE1P57/e33Z42KJWDiglqPRbba3YzVYKYlc3JyAHB1dTW4//ff1V9v27Vrp7fv8OHDeHt7o1Qq+emnnwBo27atTp0bN24QFRXFoEGD9Pr89NNP7znK0Yy4qqIZMTo7O+uUl5SUEBsby+OPP64tS01N1S4u0bh27Rrx8fG88sor2rKEhASD57pjxw4sLCwYOXKktqxywkxKSsLZ2dng8dXx8vJi3759eiO4tLQ0rKys6Nq1a43bNKVHxr3BI+Pf1Cn7evmw+gmmGpZWTVAoqvn+qFJhaWVTNwHdB9X581Rs34nFM5Oo+HI7Fn6DUTTAlcbGvocN+b0WptVgRm4uLi6A+kPUEM11r19//VWnPDo6mqNHj7JkyRIAWrVqBagXaNztvffeIy8vT2elpGb0Y2Vlha+vr8HN2ohvqpo+MzMzdcpXr15Nbm6uNnEWFRVRWFioM+oCWLduncHFJFlZWdy8eecq+NWrV1m5ciVBQUE605opKSk6yTk9Pd3gdTNjjBs3jvz8fA4dOqQtu337Njt37iQgIIBmRiwkUKlURm1Dhw67rxhNYejQYUbHeb/b+FEDqO57psLCgjXvvFzrsQwbNqzG75Hq1m3KVr6HxYTxWM6cgWLwQMpXv4+qourRaGXDhtX+e92vhzvGfKnf9vnaWo9FttrdjNVgRm7t27cnICBAe43Jx8eHgoICDh8+TFBQEH5+fowdO5bw8HBatGhBp06d+P7771m1ahVz587VLgbx8PCgV69erFixAkdHRzp16kRkZCSbNm0CdK+3ubm5ERgYyNKlSykoKMDHx4fS0lKys7OJjo7m888/17l37F40fb777rs4OTnh6urK119/rb0nTNOnvb09Li4u7N69m/Hjx6NSqdi8eTMff/wxoLuY5PLly3Ts2JFp06Yxf/588vPzWb58Ofb29nzwwQfavs+dO0dhYaFOYnR0dCQ2Npb9+/ejVCrp0KGD3qjyXsaMGYOfnx8zZsxg9erVtGvXjoiICC5cuGDUk1LEHYM7w8/VzJbZWkOfh+omnpqq2LgJhZUVFsFBAFi+MI+yeQuo2BOJ5aSn6zk6XUO6QEbuvfcrAIdm8HDNJzPEA6rBjNwAdu3axfTp04mIiCAwMJCFCxdy5coV7Shk69atPP3007z11ls88cQTfPvtt0RERLB+/XptGxYWFuzevZs+ffqwePFinnnmGQoKCnjttdcA/SeT7Nixg5CQENavX8/o0aMJDg5m48aN2mlOY2j69PLyYv78+cyYMYNWrVrx4osvYmVlRa9evbR1v/jiC65cuUKXLl0YOXIkTZo0YebMmTg4OGhHp5prZpGRkdjY2PDUU0+xaNEihgwZwvHjx3FwcNC2V3mVJUBYWBgeHh5MnDiRgQMHaqdqjaFQKNi3bx9jx45lyZIljBkzhry8PL777rsH4qkuDUl7pfpD1xDNIGNSP7BpMF8x76hITqEi+iCWr72CwkodoMLODstX/krF1i9RGbnQqq50d4Ve7ob3KVCvRp3SHyxkXVSjoVDVZJwnaiQ4OJjU1FROnDhR36E0SB8ehrN51derDZ3awMLHar+fChUcPQXHTkPxrTvlrexhbJ97fyCbWkDCz3x/tX5u43jU0Ykjvv1rvZ/yCtifCscz4VbZnXIXB3jKBzobN3khzEQD/M5oPhISEmp8n5kwLxYKeKwHDOsGL6vvwWfRY9CxdcO8t+1BZmmh/sIwqge8+pW6bEkguDvJe90YNahpyYbq7vvfDG2GBr/Xr18nMzPzvu41qy33cx7CNKzv3KqIRxv5sK1NTe5aA9ZeKe91YyXJrRpZWVl698BV3rZs2aJ3XPPmzSkvL2fhwoX1ELW++z0PIYR4EMm0ZDVcXFy0P5NzLx07dqyjaO6fuZyHEEIYQ5JbNWxsbAz+isCDxlzOQwghjCHTkkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsyGpJUW9cHRtn3/Wht719o+xbNF6S3ES9mSB3JtSZ9x++v59AEuJBJdOSQgghzI4kNyGEEGZHkpsQQgizI8lNCCGE2ZHkJoQQwuxIchNCCGF2JLkJIYQwO5LchBBCmB1JbkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsSHITQghhdiS5CSGEMDuS3IQQQpgdSW5CCCHMjvwStxC16OZtyMiF7Ct3yjb/AC4O0L4VdG4LlvIVUwiTk+QmRC34oxi+S4OE83CrTHdfygX1BtCyKQzuDMO6gY383yiEycj/TkKY2C/nYG+CetRWncISiD4B8edh2kDo2Lr24xOiMZAJESFMRKWC/SmwPc64xHa334sg4gikXayV0IRodBpdcktNTUWhUHDgwIH6DqVaubm5KBQKduzYUW3dkydP6pxXcXExy5YtIzk5uUZ9Xrx4kUWLFjFo0CDs7OxQKBSkpaXdV/yNzff/hcOn7v/48grY9AOc/910MQnRWDW65BYfHw+Aj49PPUdSvYSEBAD69etXbV0XFxfi4uIYMWIEACkpKYSFhVFUVFSjPs+cOcOuXbtwcHBg6NChNQ+6kbpUCN9W8z1iXZB6q0p5hXrkV/k6nRCiZhrdNbf4+Hjc3Nxo06ZNfYdSrYSEBBwdHfH09Ky2rlKpRKlUal8nJyejUCjw9vauUZ+PPvooly9fBmDz5s0cPHiwRsc3VpEJUFZhmrZ+L4Jjp2FUT9O0Jxq+m7ch+Tf4/RpYW0FPN3Bzqu+oHmwNcuS2b98+AgICcHBwwM7Ojp49e7Jx40YAVCoV69evp2/fvtjZ2dG+fXsWL17M9evXddqoqKhg9erVeHp6Ymtry+DBg0lPTyc+Ph5fX1+9Pr/88ksGDx5Ms2bNcHZ2ZsaMGRQUFNQo7oqKCtasWUPnzp2xtbWld+/exMbG8vDDDzNnzhwAysvLsbOzIywsTOfYsrIybG1tWbVqlbYsMTERX19ftm/fjre3N3Z2dnh7e3PkyBG9vvv378/kyZMB6NmzJwsWLEClUtGyZUsUCgUDBgww6hwsLBrkn0SDdrkQ/nvJtG3++Kt6FCfM3/FMCN0Du36Gf5+GQydhzQH48DAUldR3dA+uBvdJFhoayvjx43Fzc2Pjxo3s2bOHsWPHUlBQQEVFBUFBQSxdupRJkyaxf/9+Xn/9dTZv3szMmTN12gkJCSE8PJw5c+Zw4MABAgMDGTt2LGlpaXpTkgsXLiQkJIQBAwYQGRnJihUrOHjwINOmTatR7CEhIbzzzjvMnTuXAwcOMHnyZKZOncq5c+e0fWZkZFBSUkKfPn10jj116hSlpaU65YmJiaSnp7NhwwbCwsLYuXMnAOPGjSM7O1tbr7y8nJMnT2qP3bRpE127diUgIIC4uDji4uL44osvanQuwngJ503fZmEJZJo4YYqGJ+4MfB0Pt8v1953Lg4+OQqlMUd+XBjUtuXfvXpYvX86GDRsICQnRlo8ePRqADz/8kF27dhETE4Ofnx8A/v7+5OfnExoayqeffoqDgwPbtm1jy5YtHD16lOHDh2vrnThxgrNnz+oktx07dhAREcHWrVsJDg7Wljdt2pSpU6eSlZVFhw4dqo19+/btbNmyhZiYGO21Kn9/f5KSkti7d6+2z6SkJAC95KZZ+KEpz8nJ4dKlS/j5+fHdd99haWkJgKenJ15eXkRFRTF//nwATp8+rZMw+/Tpw4ULFwgKCjJ6xCbu34Ur1de533a7udRO26L+lZVDVMq996tQX8tNOK++F1LUTIMauYWGhuLv76+T2O62du1annzySW1i0+jUqROgXukH8O677zJq1ChtYtPo1q0boLuY5O2338bHx4epU6dSVlam3bp37w7A+fPGfS1fsWIFgYGBeoswPD09sba2pmdP9QWUpKQklEol7u7uOvWSkpJwdXWldWv1jU6JiYkAhIeHaxMbQPfu3bGysiIvL09bpkmMffv2BdSjw+LiYu1rUbv+90fttJtbS+2KhuFUDtworbqOAvjpTJ2EY3YazMgtOzub9PR0/vKXvxjcf/bsWbKysnj99df19l24oH7cQ7t27bh48SLp6en89a9/1auXk5ODu7u7djFJdnY2GRkZAFhbWxvst2XLltXGfvHiRdLS0njppZcMxubl5UWTJk0AdRKrPGoDdYKqPCXp7Oysl8jz8/MpKyvDzc1N51gXFxfteWkSo6F+6oJCoaiXfuvL/M+LsLFtrn1d3YrIe+1fvE339b++PcCMRx//k9E1Tn/5UgU07L9F71GLGBr8jyrrqID/ZuWhULStm6AeACqVyqh6DSa55eTkAODq6mpw/++/q2/+adeund6+w4cP4+3tjVKp5KeffgKgbVvdP4YbN24QFRXFoEGD9Pr89NNP7znK0Yy4qqIZMTo7O+uUl5SUEBsby+OP3/mASk1N1S4u0bh27Rrx8fG88sor2rKEhASD57pjxw4sLCwYOXKktqxywkxKSsLZ2dng8cL0Kspu1Uq75ber+VovHmilxYXV1lGpVEbVE/oaTHJzcVFfXEhLS+OJJ57Q26+57vXrr7/qlEdHR3P06FG2bt0KQKtWrQD1Ao2723nvvffIy8vTWSmpGf1YWVkZXEFpLE2fmZmZOols9erV5ObmahNnUVERhYWFOqMugHXr1hlcTHLr1i1u3ryJra0tAFevXmXlypUEBQXpTGumpKSwaNEi7ev09HTttGp9MPablbn4+yH4Lf/O68ojMA3NiO1e+yubHTyeb//euN5LU9G8xw35b/FGKby1t+pVsQqFgimPdWZLAz6PhqrBJLf27dsTEBCgvcbk4+NDQUEBhw8fJigoCD8/P8aOHUt4eDgtWrSgU6dOfP/996xatYq5c+dqF4N4eHjQq1cvVqxYgaOjI506dSIyMpJNmzYButfb3NzcCAwMZOnSpRQUFODj40NpaSnZ2dlER0fz+eef69w7di+aPt99912cnJxwdXXl66+/Jjo6WqdPe3t7XFxc2L17N+PHj0elUrF582Y+/vhjQHcxyeXLl+nYsSPTpk1j/vz55Ofns3z5cuzt7fnggw+0fZ87d47CwkKdxOjo6EhsbCz79+9HqVTSoUMHvVFlVb7++mvgzk3khw8fJiMjg2bNmmkX94g73J10k5upyH1O5q1ZE/VCke//a3i/QqF+mPbA6m9zFQYoVA3oq01BQQFvvfUWUVFR5ObmolQqGTx4MOvXr0epVFJYWMgrr7xCVFQUf/zxB927d+eFF15gxowZOu1kZmYyb948fv75Z+zs7Bg5ciTdunUjNDSUvLw87aINgD/++IPly5fzr3/9i4sXL2Jvb4+npyeBgYH87W9/Mzr2zMxM5s6dyy+//IJSqeS5557D3t6eN954g2vXrtG0aVMA/v3vf7NgwQLOnTvHQw89xIwZM7h27RqffPIJV69eBdT3+Y0bN46UlBRWrFhBVFQUTZs2ZcKECYSHh2tHigB79uxh4sSJnD9/Xju6zcjIICQkhOTkZG7evElkZCTjx483+lzudZ3ioYceIisry+h2GotfL6mXbFenJiM3a0sImwB2Nn8utsZK8x5Xd/2zvpWVwxc/QuoF9eKRuz+Mba1hrr88TPt+NajkZm6Cg4NJTU3lxIkT9R2KqEUqFayMgsvXqq5Xk+Q2oBNMkbs47tuDktxA/fdzJg/ifoWk39Rl4/rCIx7q0Z24Pw3qVgBzk5CQ8EA8w1L8OQoFjDXhwlRba3n0VmOiUKh/tHb6kDtl/t0ksf1ZktyMcPf9b4Y2Q4Pf69evk5mZ2aDuNbuf8xDG8XKDfh6maWu8Dzg2M01bQjRWktyqkZWVhbW1dZXbli1b9I5r3rw55eXlLFy4sB6i1ne/5yGMN/kR6FLFup3F26qfkhzRHfqbKEkK0Zg1mNWSDZWLi4v2Z3LupWPHjnUUzf0zl/NoyKwtYdZQ2B0P8edqdqylBTzpDcO6qqephBB/jiS3atjY2Pype+AaCnM5j4bOxgqCBoK3O3yTDHnVLDIB9WjvKR9o51Dr4QnRaEhyE6IWeLlBd1c4c1m9zDu7APKK1Eu/m1iBiyO0V4JvR3Cu/glvQogakuQmRC1RKKCzs3oTQtQtWVAihBDC7EhyE0IIYXYkuQkhhDA7ktyEEEKYHUluQgghzI4kNyGEEGZHkpsQQgizI8lNCCGE2ZHkJoQQwuxIchNCCGF2JLkJIYQwO5LchBBCmB1JbkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsyC9xCyFEI7d48WJSUlLqpW9vb2/WrVtn8nYluQkhRCOXkpJCbGxsfYdhUjItKYQQwuxIchNCCGF2JLkJIcxKYcmdf2cXwO3y+ovFWLfL4WLBndeFxfUXi7mQa25CiAdezlU4ngmncuDaXcnt/QNgoQBXR3jEA/p5gK11/cV5t5u3IeE8/HJOndgqVHf2/S0SWthCd1cY0gXcnOovzgeVJDchxAPr+k34Oh5SLty7ToVKPYLLLoDoVHjKF/p1BIWi7uK8m0oFiVmwNwGKb9273rWb8NNZ9dbbHSY+Ava2dRbmA0+SmxDigZSVD5/HqhOcsUpuw/Y4SM+BZweBlWXtxWdIWbm6/6TfanZcajacyYNZQ6Fj69qJzdyY1TW3kydPolAoOHDgAADnzp1DoVCwe/dubR1DZQ1Vbm4uCoWCHTt2VFmv8nkDFBcXs2zZMpKTk2vUZ2FhIfPmzaNNmzbY2dkxePBgjh8/fl/xC1FbLlyBT47WLLHdLeUCbPweyitMG1dVyitg8/GaJzaNG6Xwyb/VSf1B1bJlyzrry6ySm4uLC3FxcYwYMQKAxMREAHx8fLR1DJU1VAkJCQD069evynqVzxvU962EhYVRVFRkdH8qlYpx48YRGRnJmjVr2LdvH61ateKxxx6rcZIUorbcvA2bfoDSsnvXWRek3qqS/j84csq0sVXl3+mQdrHqOtXFfasMNv8AJVVMZ9YFHx8f3nzzTSIjI0lOTubEiRMcO3aMv//970ycOBEbGxu9Y4YPH05WVhZPPvlkncRoVtOSSqUSpVKpfZ2YmIijoyMeHh5VljVUCQkJODo64unpWWW9yucNkJycjEKhwNvb2+j+oqKiiI2NJTo6mtGjRwPw6KOP4uXlxRtvvEF0dHSNz0EIU4tKgas3TNPWdyehlzu0czBNe/dyqRAOnjRNW38Uw75keKa/adqridGjR7Ns2TIeeeQRg/uHDRvG4sWL+f333/noo49YuXIlpaWlDB8+nG+//RY7OzsCAwOJioqq9VhrbeQWExPD+PHjcXd3x9bWFldXV2bNmkVhYaG2jo+PD1OnTmXPnj30798fOzs7OnbsyK5duwy2uW/fPgICAnBwcMDOzo6ePXuyceNG7f7+/fszefJk7evExES9EVrlMmPiNEZFRQVr1qyhc+fO2Nra0rt3b2JjY3n44YeZM2eOtl55eTl2dnaEhYXpHF9WVoatrS2rVq3SidXX15ft27fj7e2NnZ0d3t7eHDlyROfYyufds2dPFixYgEqlomXLligUCgYMGFDtOXzzzTcolUoCAwO1ZTY2NkyZMoXDhw9z44aJPlGEuE9FNyHujOnaK1fBv0+brr17iTlt2inQn8/q3vJQ25o1a8amTZuIjo7mkUceoaCggIiICIKCgvDx8aF3794EBgby5ptvkpycTOvWrbWXRebOnatNbJ999hkLFy6sk5hrbeSWmprKkCFDmD17Nvb29pw+fZo333wTgM8//5yysjJOnTrF1atXyc3NZenSpbRo0YK33nqL559/ntGjR9OiRQtte6GhoYSHhzN9+nReeOEFmjZtyvHjxykoUN8cUl5ezsmTJxk/frz2mKSkJGbPnq0TV+Wy6uI0VkhICJGRkYSGhuLj48OPP/7I1KlT+f3331myZIm2XkZGBiUlJfTp00fn+FOnTlFaWqpTnpiYiKWlJRs2bCAsLAyFQsFbb73FuHHjyMjIwN3d3eB5b9q0ieDgYNzc3HjnnXcA9EZ2hqSlpeHl5YWi0jKyHj16UFZWRkZGxgMxnSvM189nTX+dLDkLxveFZk1M265G8S316khTqlDBT2dgVE/TtmuIvb09hw4dYuDAgZSUlPDWW28RERHBzZu6FzxPnDjBoUOHCA8P59FHH2X9+vV069aNTz75BIVCwWeffcbcuXNRqVT36Mm0ai25/eUvf9H+u6KigkGDBpGamsrRo0cBSE9Pp7S0lC5dunDgwAHtB2ppaSnjxo3jt99+o2dP9X+5vXv3snz5cjZs2EBISIi2Xc3UGcDp06d1ksb58+cpKCjQ+TA2VFZdnMbYvn07W7ZsISYmhqFDhwLg7+9PUlISe/fu1ekvKSkJQC+5aa5pacpzcnK4dOkSfn5+fPfdd1haqpd1eXp64uXlRVRUFPPnz9c7b00bFy5cICgoyKgRm0ZBQQHdu3fXK3dyctLuF6I+ZV4yfZtlFZD1O3i5mb5tULddGzeSZ16qm+S2a9cuBg4cSFZWFqNHjyYjI6PaY77//nuWLFnCt99+i5WVFbdu3eK9996rs8QGtTQtWV5ezrZt2xgyZAht27bF0tISa2trPvnkE5o3bw7c+TDXjEg0NB+grq6u2rLQ0FD8/f11Eltlmvb69u0L3Fk44uvrq61TucyYOI2xYsUKAgMDtYlNw9PTE2tra22SBnVyUyqVuLu769RNSkrC1dWV1q1b68QaHh6uTWwA3bt3x8rKiry8PIPnDerRYXFxsU6ZMVQqld6oDTBYJkRdU6l0n+JhShdq8Xvbxau11G6lG79rw+zZsxk9ejT5+fkMHz7cqMQG6sUje/bswcrKivPnz2NjY8OGDRvq9LOkVkZu06dPJzIykgULFvDqq6/SqlUrrKysCAgIoEePHoD6Q9nR0VHvwmRqaipubm7a0UJ2djbp6ek6IyxDkpOTcXFxoU2bNsCdhSMdO3bU1qlcZkyc1bl48SJpaWm89NJLevsuXLiAl5cXTZrcme9ISkrSG7Vp4q88Jens7Iyfn59Ovfz8fMrKynBzczN43ppjQX90WB2lUmlwdKYp0/w3qY4kQ1EbrJrY8eIG3eu+1a2IvNf+xdt0X7//wWc8vmGO4cp/kv/zH9MrYL5RcVW3/+64S8ugabMW3CoxfkV0TdjZ2WnXALz44oucP3/eqOPuXjzy2Wef8dprr5GWloafnx/PPPMMO3fu1KkfGxtbo88MY0d/Jh+5nTx5ku3bt/PBBx+wevVqxowZw8CBA7l16xbXrl3TTtElJyfTt29fvZNKTEzUGXHk5OQAuiM5QyonjeoWkxgbZ3UuXlSv7XV2dtYpLykpITY2Vq+d1NRUvaRz7do14uPjdcoTEhJo166dXn87duzAwsKCkSNHGjxvTZmzs7PB46vi5eVFenq63h9PWloaVlZWdO3atUbtCWFKCmrxS1MtfiGr1S97itq7m2vatGk4Ojry448/8tVXXxl1TOXENnfuXAoKCli2bBkAL7zwQq3FW5nJR27Z2dkAOtdubt++zV//+ldAvUJSpVKRmprKvHnzdI6tqKggJSVFZwGGi4sLoP6AfeKJJ+7Zb0pKCosWLdK+rm4xiTFxGqNVq1YAZGZm8vjjj2vLV69eTW5urk6iLioqorCwUDvq0li3bp3BxSS3bt3i5s2b2Nqqn7lz9epVVq5cSVBQkHZas/J5g/p6pqFrZ9UZN24cGzdu5NChQ9oVk7dv32bnzp0EBATQrFkzo9qpy3l10XhUqOC1XXDrrutXlUdgGpqRz732V/aXF2Zx5LNZfy7Ae4hOhe/SdMtMEbeVJRQX/YGlCfLbsGHD9H7PberUqQB88sknRrVhKLFpPgu2bdvGmjVr8PPzw9XVVTtoARg6dCgxMTF//iQqMXly6927N7a2trz22mu8+eabXLlyhbVr11JQUICFhQXe3t6cO3eOwsJCvQSSmZlJUVGRTkJo3749AQEB2mtPPj4+FBQUcPjwYYKCgvDz89O2p0kOWVlZXLlyRaf9ymXGxGkMDw8PevXqxbvvvouTkxOurq58/fXX2nvC7o7B3t4eFxcXdu/ezfjx41GpVGzevJmPP/4Y0F1McvnyZTp27Mi0adOYP38++fn5LF++HHt7ez744AMAvfPWcHR0JDY2lv3796NUKunQoYPeyNKQMWPG4Ofnx4wZM1i9ejXt2rUjIiKCCxcuVPuUFCFqm4UCXJ3g/O+mb9u9+sXE9622Hnrs6oBJEpshCoVC+9lV+dYjQ6pKbAA3btwgLi6OkSNH4uvrq5PcaovJ3xpXV1e2b99Obm4u48aN4/333+fll19m8ODBdO3alWbNmmkXQdy92APuXCuqvBBi165dTJ8+nYiICAIDA1m4cCFXrlzRjk4qrzQ05skkxsRpDAsLC3bv3o2Xlxfz589nxowZtGrVihdffBErKyt69eqlU/+LL77gypUrdOnShZEjR9KkSRNmzpyJg4MDHTp00Ik1MjISGxsbnnrqKRYtWsSQIUM4fvw4Dg4OBs9bIywsDA8PDyZOnMjAgQP56aefjDoXhULBvn37GDt2LEuWLGHMmDHk5eXx3XffyS0AokHo1Kb6OjWlADq2Mn27Gh1aqROzqXnUwnuh4erqSsuWLbl8+TKXLlW9RLW6xKaRkpICqC9/1AWFSuaQakVwcDCpqamcOHGivkMRwmzkF0H4PqjuQ6sm03s93NQPJK5NG7+HE9nV16tJ3K+PgTYtqq9njMrTko6OjixcuJDr16+zdu3aex5nb29PVlYWTk5O1d7H5u/vz7Bhwzh27JjONOQDMy0p1BISEmp0j5kQonqt7NWPy0o1IlEYy78O1kn5dzMuuRmrh5vpEpshV69e5e233662XlFREVOmTGHs2LEsWrSoyuvtx44d49ixY6YMs0pm9eDk2lBWVlblZug/5vXr18nMzKzxfWa16X7OQ4iGaEI/aGqiHxwd5Amd2pqmrap0bK3+0VFTsLWGiVU/S71OHT58mIULFza4zxBJblXIysrC2tq6ym3Lli16xzVv3pzy8vI6e4Zade73PIRoiFo2haBBVV/HWryt+qk9N0cYW4ffP8f0AfdqFpdUF7cCmDoAHOxMGppZkmnJKri4uBAfH19lnbtvEm+ozOU8hNDo4QbTh8AX/7m/Z026O8Fcf/UoqK40sYJ5w+Gfx+C3KzU/3lKhTuq925s+NnMkya0KNjY2eis6H0Tmch5C3M27PbRtof5l62wjH59loYAR3dXPZKzrX+EG9cOZFz6mvu/tyCnjH5/l5gjTBoKLY+3GZ04kuQkhHljtHGDxKPVijeOZcDbPcD1ba+jnAUM6Q9u6+zFog6ws4fHe4NtRHXP8OSi5bbiux/9dq+vdvvbuaTNXktyEEA80Swvo85B6K74FOQWQf109XWlrDa6O6hGeRQNLDm1awARf9c/t5BWp4y65rT4fZXP1zd92+j9oLYwkyU0IYTbsbKCzM3Su70BqwMICnFuqN2E6Dey7jBBCCPHnSXITQghhdmRaUgghGjljHxRf2bkLuQB4tG+n8++66Ls68mxJIYQQ9+W1Vf8EYOWrc3T+3RDItKQQQgizI8lNCCGE2ZHkJoQQwuxIchNCCGF2JLkJIYQwO5LchBBCmB1JbkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsSHITQghhdiS5CSGEMDuS3IQQQpgdSW5CCCHqXExMDF5eXnh6ejJr1izKy8tN2r4kNyGEEHWqoqKCWbNmsXv3bs6cOcO1a9f48ssvTdqHJDchhBB1Kj4+HhcXF7p37w7AzJkz2bNnj0n7kOQmhBCiTl28eBF3d3ft6/bt25OdnW3SPqxM2poQQgizlXzqV77/5YRe+T827dH7dxulA8+MGY6FQqFXX6VSobirXKVSmTxWGbkJIYQwSq+unbCwUJCbd4XcvCva8sr/vpxfgF+/XgYTG4C7uzsXLlzQvs7OzsbNzc2ksUpyE0IIYRRLSwueecIfKyvLKusNH9QXt3at77nf19eXnJwc0tPTAdiwYQMTJkwwaayS3P5PVlYWCoWCzZs313coJhcTE4NCoSAqKqrauh06dOD555/Xvj5y5AjLli2rveCEEA+UNq0cGT20/z33u7drjf/APlW2YWlpyWeffcbEiRPp1KkTzZs3Jzg42KRxyjU3oSMyMpIWLVpoXx85coRVq1ZJghNCaA308eL0md8481uOTrm1lSWTn/TH0qL6cdPw4cO1I7faICO3GiotLa3vEGpVnz596NSpU32HIYRowCwUCiY9PhTbJjY65U8MH0hrJ4f6CaqSBpHcLl++TEhICG5ubjRp0gRnZ2dGjhxJZmYmXl5ejBkzRu+Y06dPo1Ao2LhxIwCbN29GoVDwww8/MGPGDBwdHWnTpg3Tp0/njz/+0Dn26tWrPP/88zg4OGBvb8+ECRPIycnR6+P555+nVatW/PzzzwwZMgQ7OzteffVVAM6ePcukSZNwcnLC1tYWb29vvZsQNTEdO3aMKVOm0LJlS5ycnFi6dCkVFRX88ssv+Pn50axZM7p168Y333yjF0N6ejpPP/00SqUSW1tb+vbta7CeMa5fv86cOXNQKpU0a9aMcePG6S2/vXtactmyZaxatQoAhUKh3YQQomWL5owfOUT7uktHd/p7d6vHiHQ1iOQWHBzMDz/8wMqVKzl8+DAff/wx3bt3p7CwkBdeeIHo6Gh+++03nWPWr1+Pg4MDU6ZM0Sl//vnnad26NV999RVvvvkmu3fvZvHixdr9FRUVjBkzht27dxMaGsqePXt46KGHmDp1qsHYiouLeeaZZ5g8eTL79+9nypQp5ObmMmjQIH755RfWrl3L3r17efjhhwkODuajjz7Sa2PWrFl06dKFPXv2EBISwvvvv8+SJUsIDg5mxowZ7N27F1dXVyZNmqRznidOnKB///7k5OTw8ccf880339CjRw+eeuopIiMja/w+v/zyyxQVFfHll1/yj3/8g7i4OIYPH05xcbHB+rNmzdLOg8fFxWk3IYQA8O7uSa+uHtjZNmHi6Ecb1JffBnHN7ccffyQ8PJxnn31WW6ZZOdO1a1f+3//7f/zzn/8kPDwcgJKSErZu3cpzzz2HnZ2dTlsTJkxg9erVADz22GNkZmby+eefs2nTJhQKBQcPHuQ///kPn3/+OTNnzgRg5MiR3Lhxg88++0wvtpKSEtasWcPEiRO1Za+88gr5+fmcOnWKrl27AvD444+Tl5dHaGgos2fPxsbmznB98uTJvP322wAEBASwf/9+/vGPf/Cf//yHQYMGAdC5c2c6derEnj17WLJkCQBLly6lbdu2HDt2jKZNmwIwatQocnJyeP3113nqqadq9D536NCBHTt2aF937tyZYcOGsWXLFubPn69X383NDRcXFwAGDBhgdD+vrfpnjeISQjz43v14W530s/LVOUbVaxAjt379+vHee++xbt06Tp48qXNDn729PdOnT2fDhg3cvn0bgJ07d/LHH38wb948vbYqT2H27NmT0tJSLl++DEBsbCyA3ohv2rRpBmNTKBR6bcbExNC3b19tYtOYPn06V69e5cQJ3ZscH3/8cZ3X3bp1o0WLFtrEBuDh4YGNjY323o+bN29y7Ngxnn76aaytrSkrK9Nuo0ePJiMjg7y8PIMx30vlcx46dCjOzs7a90QIIcxFgxi5ffXVV4SFhbFmzRpeeukl2rRpw4wZM1i2bBm2trYsWLCAjz76iL179/LMM8+wfv16hg8frpdcAJycnHReN2nSBFAnC4ArV67QvHlzmjVrplPP2dnZYGyOjo7aNjQKCgro1k1/brldu3baPiq3cTcbGxu9MgBra2udOMvKyli9erV2JFpZfn4+bdq0MbjPEEPn2LZtW714/yxjv1kJIURtaRDJrXXr1kRERBAREcG5c+fYtm0by5Ytw8rKiuXLl9O1a1dGjBjB+vXrefjhh/nll1/YvXv3ffWlVCq5fv06N27c0Elwly5dMljf0ByyUqk0WD83N1e7/89ydHTEwsKCWbNmMXv2bIN1PDw8atSmoZgvX75s8EvCnyHTkkKI2vJATUvezcPDg9DQULp06cLJkye15S+++CIxMTEsWbKEdu3aMX78+Ptqf+jQoYB6avNu27dvN7qNYcOGkZSUREZGhk75tm3bcHJyolevXvcV293s7OwYOnQoKSkp9OnTB19fX73N1ta2Rm1WPufY2FguXbqkfU8M0YxaS0pKan4SQghRT+p95FZYWMiIESOYNm0a3bp1o0mTJhw6dIj//ve/LFq0SFtv7NixtG/fnmPHjhEaGoqV1f2FHhgYyODBg1m0aBGFhYX06NGDgwcPcujQIaPbWLJkCVu2bGHUqFG8/fbbtGnThq1bt3L06FE++eQTncUkf8a6devw8/PD39+fOXPm4O7uTkFBAWlpaZw5c4YtW7bUqL2srCymTp3K9OnTtYtSPD09ee655+55jOYnKd577z1GjRqFpaUlvr6+VfYj05JCiPpW78nN1tYWHx8fNm7cqF0G36lTJz766COdFXyWlpZMmDCBDz/8kDlz7v/D08LCgm+//ZbFixcTFhZGRUUFjz32GDt27GDw4MFGtdG2bVt+/PFHXn31VRYvXkxxcTHdu3dn27Zt91yYcj969epFQkICYWFhvPzyy1y5coVWrVrRo0cPnZWlxlqzZg1Hjx7l2Wef5ebNm4wYMYKIiAi9Fad3e/rpp5k9ezYffvghy5YtQ6VS1coTvIUQwpQUqgfkk6qiooKuXbvi5eV1X/d4CSGEaDzqfeRWnaKiIk6fPs3u3bv59ddfzfLBxkIIIUyrwSe3xMRE/P39ad26NWvWrNG5N0xAWVlZlfstLS0b1FMDhBCiLjww05JCX1ZWFh07dqyyzqZNm3R+wkYIIRoDSW4PsFu3buk9DaWyjh07muS+OyGEeJBIchNCCGF2GtxN3EIIIcSfJclNCCGE2ZHkJoQQwuxIchNCCGF2JLkJIYQwO5LchBBCmB1JbkIIIcyOJDchhBBmR5KbEEIIsyPJTQghhNmR5CaEEMLsSHITQghhdiS5CSGEMDuS3IQQQpgdSW5CCCHMjiQ3IYQQZkeSmxBCCLMjyU0IIYTZkeQmhBDC7EhyE0IIYXYkuQkhhDA7ktyEEEKYHUluQgghzI4kNyGEEGbn/wMspuJ/40lugAAAAABJRU5ErkJggg==\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 14, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "qc_init = QuantumCircuit(cq)\n", + "qc_init = QuantumCircuit(cq, lq, sb)\n", "qc_init.h(cq[0])\n", "qc_init.cx(cq[0],cq[1])\n", "qc_init.x(cq[0])\n", "\n", - "(qc_init+qc).draw()" + "qc_init.compose(qc).draw()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -506,10 +603,24 @@ } ], "source": [ - "counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()\n", + "counts = execute(qc_init.compose(qc), Aer.get_backend('qasm_simulator')).result().get_counts()\n", "print('Results:',counts)" ] }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "tags": [ + "sanity-check" + ] + }, + "outputs": [], + "source": [ + "# In such cases the output is always '1'.\n", + "assert list(counts.keys()) == ['1']" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -542,7 +653,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -560,14 +671,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "n = 3\n", "T = 1\n", "\n", - "code = RepetitionCode(n,T)" + "code = RepetitionCode(n, T)" ] }, { @@ -586,17 +697,19 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 18, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -607,17 +720,19 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "" + ], "text/plain": [ - "
" + "
" ] }, - "execution_count": 19, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -639,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 27, "metadata": { "scrolled": false }, @@ -648,16 +763,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Logical 0 : {'000 00': 1024} \n", - "\n", - "Logical 1 : {'111 00': 1024} \n", - "\n" + "Logical 0: {'000 00': 1024}\n", + "Logical 1: {'111 00': 1024}\n" ] } ], "source": [ "def get_raw_results(code,noise_model=None):\n", - "\n", " circuits = code.get_circuit_list()\n", " raw_results = {}\n", " for log in range(2):\n", @@ -667,7 +779,7 @@ "\n", "raw_results = get_raw_results(code)\n", "for log in raw_results:\n", - " print('Logical',log,':',raw_results[log],'\\n')" + " print(f'Logical {log}: {raw_results[log]}')" ] }, { @@ -681,26 +793,24 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Logical 0 : {'000 00 00 00 00': 1024} \n", - "\n", - "Logical 1 : {'111 00 00 00 00': 1024} \n", - "\n" + "Logical 0: {'000 00 00 00 00': 1024}\n", + "Logical 1: {'111 00 00 00 00': 1024}\n" ] } ], "source": [ - "code = RepetitionCode(n,4)\n", + "code = RepetitionCode(n, 4)\n", "\n", "raw_results = get_raw_results(code)\n", "for log in raw_results:\n", - " print('Logical',log,':',raw_results[log],'\\n')" + " print(f'Logical {log}: {raw_results[log]}')" ] }, { @@ -712,26 +822,24 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Logical 0 : {'00000 0000 0000 0000 0000': 1024} \n", - "\n", - "Logical 1 : {'11111 0000 0000 0000 0000': 1024} \n", - "\n" + "Logical 0: {'00000 0000 0000 0000 0000': 1024}\n", + "Logical 1: {'11111 0000 0000 0000 0000': 1024}\n" ] } ], "source": [ - "code = RepetitionCode(5,4)\n", + "code = RepetitionCode(5, 4)\n", "\n", "raw_results = get_raw_results(code)\n", "for log in raw_results:\n", - " print('Logical',log,':',raw_results[log],'\\n')" + " print(f'Logical {log}: {raw_results[log]}')" ] }, { @@ -745,7 +853,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 30, "metadata": { "scrolled": true }, @@ -754,21 +862,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "Logical 0 : {'000 00': 660, '000 01': 75, '100 00': 47, '100 01': 6, '100 10': 4, '101 00': 7, '110 00': 4, '110 01': 2, '111 00': 2, '000 10': 66, '000 11': 3, '001 00': 55, '001 01': 6, '001 10': 2, '010 00': 49, '010 01': 22, '010 10': 6, '010 11': 2, '011 00': 3, '011 01': 2, '011 11': 1} \n", + "Logical 0: {'011 11': 1, '010 11': 1, '001 01': 3, '101 00': 6, '100 10': 12, '110 00': 1, '100 00': 49, '110 01': 1, '010 10': 12, '100 01': 5, '010 00': 52, '010 01': 26, '000 00': 650, '000 10': 64, '011 00': 5, '001 00': 52, '000 11': 6, '000 01': 74, '001 10': 4}\n", "\n", - "Logical 1 : {'100 00': 3, '100 01': 1, '100 10': 2, '100 11': 1, '101 00': 55, '101 01': 20, '101 10': 5, '101 11': 15, '110 00': 56, '110 01': 21, '110 10': 7, '110 11': 3, '111 00': 613, '111 01': 61, '111 10': 65, '111 11': 7, '001 00': 3, '001 01': 3, '001 10': 1, '001 11': 2, '010 00': 3, '010 01': 2, '010 10': 4, '011 00': 34, '011 01': 10, '011 10': 24, '011 11': 3} \n", + "Logical 1: {'011 11': 2, '100 10': 1, '010 10': 1, '101 10': 9, '110 11': 1, '000 11': 1, '001 11': 1, '101 00': 47, '100 01': 3, '010 00': 4, '101 01': 31, '001 01': 1, '110 00': 40, '110 01': 24, '100 00': 5, '001 10': 2, '111 01': 74, '001 00': 3, '011 00': 59, '100 11': 7, '011 10': 25, '111 00': 574, '011 01': 5, '101 11': 20, '010 11': 4, '110 10': 6, '111 11': 5, '111 10': 69}\n", "\n" ] } ], "source": [ - "code = RepetitionCode(3,1)\n", + "code = RepetitionCode(3, 1)\n", "\n", - "noise_model = get_noise(0.05,0.05)\n", + "noise_model = get_noise(0.05, 0.05)\n", "\n", "raw_results = get_raw_results(code,noise_model)\n", "for log in raw_results:\n", - " print('Logical',log,':',raw_results[log],'\\n')" + " print(f'Logical {log}: {raw_results[log]}\\n')" ] }, { @@ -792,7 +900,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -812,20 +920,20 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "P = {'0': 0.0194, '1': 0.028}\n" + "P = {'0': 0.0219, '1': 0.0253}\n" ] } ], "source": [ - "P = lookuptable_decoding(raw_results,table_results)\n", - "print('P =',P)" + "P = lookuptable_decoding(raw_results, table_results)\n", + "print('P =', P)" ] }, { @@ -850,7 +958,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -859,24 +967,24 @@ "text": [ "\n", "Logical 0:\n", - "raw results {'000 00 00': 476, '000 01 00': 58, '000 10 00': 55}\n", - "processed results {'0 0 00 00 00': 476, '0 0 00 01 01': 58, '0 0 00 10 10': 55}\n", + "raw results {'000 10 00': 55, '000 00 00': 463, '000 01 01': 56, '000 01 00': 52}\n", + "processed results {'0 0 00 10 10': 55, '0 0 00 00 00': 463, '0 0 01 01 00': 56, '0 0 00 01 01': 52}\n", "\n", "Logical 1:\n", - "raw results {'111 00 00': 427, '111 00 01': 51}\n", - "processed results {'1 1 00 00 00': 427, '1 1 01 01 00': 51}\n" + "raw results {'111 10 00': 53, '111 00 00': 437, '111 01 00': 59, '111 10 10': 54}\n", + "processed results {'1 1 00 10 10': 53, '1 1 00 00 00': 437, '1 1 00 01 01': 59, '1 1 10 10 00': 54}\n" ] } ], "source": [ - "code = RepetitionCode(3,2)\n", + "code = RepetitionCode(3, 2)\n", "\n", - "raw_results = get_raw_results(code,noise_model)\n", + "raw_results = get_raw_results(code, noise_model)\n", "\n", - "results = code.process_results( raw_results )\n", + "results = code.process_results(raw_results)\n", "\n", - "for log in ['0','1']:\n", - " print('\\nLogical ' + log + ':')\n", + "for log in ['0', '1']:\n", + " print(f'\\nLogical {log}:')\n", " print('raw results ', {string:raw_results[log][string] for string in raw_results[log] if raw_results[log][string]>=50 })\n", " print('processed results ', {string:results[log][string] for string in results[log] if results[log][string]>=50 })" ] @@ -943,7 +1051,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -960,7 +1068,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 35, "metadata": { "tags": [ "uses-hardware" @@ -982,7 +1090,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, "metadata": { "tags": [ "uses-hardware" @@ -1019,7 +1127,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 37, "metadata": { "tags": [ "uses-hardware" @@ -1042,7 +1150,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 38, "metadata": { "tags": [ "uses-hardware" @@ -1068,7 +1176,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 39, "metadata": { "tags": [ "uses-hardware" @@ -1094,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 40, "metadata": { "tags": [ "uses-hardware" @@ -1122,7 +1230,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 41, "metadata": { "tags": [ "uses-hardware" @@ -1152,7 +1260,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 42, "metadata": { "tags": [ "uses-hardware" @@ -1177,7 +1285,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 43, "metadata": { "tags": [ "uses-hardware" @@ -1200,7 +1308,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 44, "metadata": { "tags": [ "uses-hardware" @@ -1223,7 +1331,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": { "tags": [ "uses-hardware" @@ -1256,13 +1364,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": { "tags": [ "uses-hardware" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "" + ], + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -1299,7 +1420,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": { "tags": [ "uses-hardware" @@ -1334,13 +1455,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": { "tags": [ "uses-hardware" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'count': 29.0,\n", + " 'mean': 0.1839624024105741,\n", + " 'std': 0.08969281029182916,\n", + " 'min': 0.032099523882660116,\n", + " '25%': 0.1202076677316294,\n", + " '50%': 0.15479808944854537,\n", + " '75%': 0.2585266030013643,\n", + " 'max': 0.3820573455512858}" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import pandas as pd\n", "\n", @@ -1356,13 +1495,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": { "tags": [ "uses-hardware" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'count': 43.0,\n", + " 'mean': 0.03964249408264689,\n", + " 'std': 0.02227486941657462,\n", + " 'min': 0.01279016878072245,\n", + " '25%': 0.025389504940856747,\n", + " '50%': 0.03296455263355727,\n", + " '75%': 0.046331516695269206,\n", + " 'max': 0.11660000000000004}" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "if step_3:\n", "\n", @@ -1390,11 +1547,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'qiskit-terra': '0.21.2', 'qiskit-aer': '0.10.4', 'qiskit-ignis': None, 'qiskit-ibmq-provider': '0.19.2', 'qiskit': '0.37.2', 'qiskit-nature': '0.4.1', 'qiskit-finance': '0.3.2', 'qiskit-optimization': '0.4.0', 'qiskit-machine-learning': '0.4.0'}" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import qiskit\n", "qiskit.__qiskit_version__" @@ -1417,7 +1585,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9" + "version": "3.8.5" } }, "nbformat": 4,