diff --git a/docs/tutorials/advanced-techniques-for-qaoa.ipynb b/docs/tutorials/advanced-techniques-for-qaoa.ipynb index 3c62a7d241c..e968a46eda0 100644 --- a/docs/tutorials/advanced-techniques-for-qaoa.ipynb +++ b/docs/tutorials/advanced-techniques-for-qaoa.ipynb @@ -9,15 +9,33 @@ "title: Advanced techniques for QAOA\n", "description: This notebook introduces advanced techniques to improve the performance of the Quantum Approximate Optimization Algorithm (QAOA) with a large number of qubits.\n", "---\n", - "\n", - "\n", - "{/* cspell:ignore setminus pysat lbrack IEICE frameon */}\n", + "{/* cspell:ignore pysat, lbrack, frameon, IEICE */}\n", "\n", "# Advanced techniques for QAOA\n", "\n", "*Usage estimate: 3 minutes on a Heron r2 processor (NOTE: This is an estimate only. Your runtime may vary.)*" ] }, + { + "cell_type": "markdown", + "id": "1a6bbeef-966f-45e1-89aa-e964ef891eeb", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "\n", + "Users should be familiar with the basics of the Quantum Approximate Optimization Algorithm (QAOA). See the following resources for an introduction to QAOA:\n", + "\n", + "* The [Solve utility-scale quantum optimization problems](/docs/tutorials/quantum-approximate-optimization-algorithm) tutorial\n", + "* The [Utility-scale QAOA](/learning/courses/quantum-computing-in-practice/utility-scale-qaoa#utility-scale-qaoa) lesson (part of the [Quantum computing in practice](/learning/courses/quantum-computing-in-practice) course) in IBM Quantum® Learning\n", + "\n", + "## Learning outcomes\n", + "\n", + "After going through this tutorial, users should be able to do the following:\n", + "* Use advanced techniques that help improve QAOA transpilation and provide a means for improving QAOA performance\n", + "\n", + "For a detailed walkthrough of the contents of this tutorial, see this [Qiskit video](https://youtu.be/rBfK-l-qSNk?si=PC28gFAdu4JYSYdk)." + ] + }, { "cell_type": "markdown", "id": "ea97567d-810f-4cca-8edf-a47d70ea870a", @@ -25,14 +43,16 @@ "source": [ "## Background\n", "\n", - "This notebook introduces advanced techniques to improve the performance of the **Quantum Approximate Optimization Algorithm (QAOA)** with a large number of qubits.\n", - "See the [Solve utility-scale quantum optimization problems](/docs/tutorials/quantum-approximate-optimization-algorithm) tutorial for an introduction to QAOA.\n", + "This tutorial introduces two advanced techniques to improve the performance of the **Quantum Approximate Optimization Algorithm (QAOA)** at a large number of qubits.\n", + "\n", "\n", "The advanced techniques in this notebook include:\n", "\n", - "* **SWAP strategy with SAT initial mapping**: This is a specifically designed transpiler pass for QAOA that uses a SWAP strategy and a SAT solver together to improve the selection of which physical qubits on the QPU to use. The SWAP strategy exploits the commutativity of the QAOA operators to reorder gates so that layers of SWAP gates can be simultaneously executed, thus reducing the depth of the circuit [\\[1\\]](#references). The SAT solver is used to find an initial mapping that minimizes the number of SWAP operations needed to map the qubits in the circuit to the physical qubits on the device [\\[2\\]](#references) .\n", - "* **CVaR cost function**: Typically the expected value of the cost Hamiltonian is used as the cost function for QAOA, but as was shown in [\\[3\\]](#references) , focusing on the tail of the distribution, rather than the expected value, can improve the performance of QAOA for combinatorial optimization problems. The CVaR accomplishes this. For a given set of shots with corresponding objective values of the considered optimization problem, the Conditional Value at Risk (CVaR) with confidence level $\\alpha \\in [0, 1]$ is defined as the average of the $\\alpha$ best shots [\\[3\\]](#references).\n", - "Thus, $\\alpha = 1$ corresponds to the standard expected value, while $\\alpha=0$ corresponds to the minimum of the given shots, and $\\alpha \\in (0, 1)$ is a tradeoff between focusing on better shots, while still applying some averaging to smooth out the optimization landscape. Additionally, the CVaR can be used as an error mitigation technique to improve the quality of the objective value estimation [\\[4\\]](#references)." + "* **SWAP strategy with SAT initial mapping**: This is a specifically designed transpiler pass for QAOA that uses a SWAP strategy and a SAT solver together to improve the selection of which physical qubits on the QPU to use. The SWAP strategy exploits the commutativity of the QAOA operators to reorder gates so that layers of SWAP gates can be simultaneously executed, thus reducing the depth of the circuit [\\[1\\]](#references). The SAT solver is used to find an initial mapping that minimizes the number of SWAP operations needed to map the qubits in the circuit to the physical qubits on the device [\\[2\\]](#references).\n", + "* **CVaR cost function**: Typically the expected value of the cost Hamiltonian is used as the cost function for QAOA, but as was shown in [\\[3\\]](#references), focusing on the tail of the distribution, rather than the expected value, can improve the performance of QAOA for combinatorial optimization problems. The CVaR accomplishes this. For a given set of shots with corresponding objective values of the considered optimization problem, the Conditional Value at Risk (CVaR) with confidence level $\\alpha \\in [0, 1]$ is defined as the average of the $\\alpha$ best shots [\\[3\\]](#references).\n", + "Thus, $\\alpha = 1$ corresponds to the standard expected value, while $\\alpha=0$ corresponds to the minimum of the given shots, and $\\alpha \\in (0, 1)$ is a tradeoff between focusing on better shots, while still applying some averaging to smooth out the optimization landscape. Additionally, the CVaR can be used as an error mitigation technique to improve the quality of the objective value estimation [\\[4\\]](#references).\n", + "\n", + "By the end of this tutorial, you should be able to use these techniques to get the best results from running QAOA for your optimization problems." ] }, { @@ -105,16 +125,36 @@ "In this example, we use a graph with 100 nodes that is based on a hardware coupling map." ] }, + { + "cell_type": "markdown", + "id": "663d13f5-a5f7-4b67-a89b-26deb41224ec", + "metadata": {}, + "source": [ + "## Small-scale simulator example\n", + "\n", + "Since the goal of this tutorial is to show how QAOA performs at scales beyond what a simulator can handle, we will forgo this step.\n", + "\n", + "f you would like to try a simulator-based QAOA workflow, try out the [Quantum approximate optimization algorithm](/docs/tutorials/quantum-approximate-optimization-algorithm) tutorial." + ] + }, + { + "cell_type": "markdown", + "id": "6ca05a7c-5fde-4485-a3ad-c0ba02844e50", + "metadata": {}, + "source": [ + "## Large-scale hardware example" + ] + }, { "cell_type": "markdown", "id": "b825afbf-10fd-4926-bd65-05272044f107", "metadata": {}, "source": [ - "## Step 1: Map classical inputs to a quantum problem\n", + "### Step 1: Map classical inputs to a quantum problem\n", "\n", - "### Graph → Hamiltonian\n", + "#### Graph → Hamiltonian\n", "\n", - "First, map the problem onto a quantum circuit that is suited for the QAOA. Details on this process can be found in the [introductory QAOA tutorial.](/docs/tutorials/quantum-approximate-optimization-algorithm)" + "First, let's map the problem onto a quantum circuit that is suited for the QAOA. Details on this process can be found in the [introductory QAOA tutorial](/docs/tutorials/quantum-approximate-optimization-algorithm)." ] }, { @@ -142,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": null, "id": "e04ce982-8294-4ebe-8dcc-f74205938800", "metadata": {}, "outputs": [ @@ -158,12 +198,15 @@ } ], "source": [ + "# Check if the coupling map is symmetric. We will add a conditional below\n", + "# to avoid over-counting edges for symmetric/bi-directional coupling maps.\n", + "\n", "backend.coupling_map.is_symmetric" ] }, { "cell_type": "code", - "execution_count": 97, + "execution_count": null, "id": "8b864d32-9483-45ea-831f-60488e330adb", "metadata": {}, "outputs": [ @@ -186,7 +229,12 @@ "\n", "for edge in backend.coupling_map:\n", " if (edge[0] < n) and (edge[1] < n):\n", - " if (edge[1], edge[0], w) not in elist:\n", + " # Conditional to avoid over-counting edges\n", + " if (\n", + " edge[1],\n", + " edge[0],\n", + " w,\n", + " ) not in elist:\n", " elist.append((edge[0], edge[1], w))\n", "\n", "graph_100.add_edges_from(elist)\n", @@ -252,9 +300,9 @@ "id": "4e576068-53e7-4a06-a83b-87e95de141e9", "metadata": {}, "source": [ - "## Step 2: Optimize problem for quantum hardware execution\n", + "### Step 2: Optimize problem for quantum hardware execution\n", "\n", - "### SWAP strategy with the SAT initial mapping\n", + "#### SWAP strategy with the SAT initial mapping\n", "\n", "We will demonstrate how to build and optimize QAOA circuits using the **SWAP strategy with SAT initial mapping**, a specifically designed transpiler pass for QAOA applied to quadratic problems.\n", "\n", @@ -299,7 +347,7 @@ "source": [ "#### Remap the graph using a SAT mapper\n", "\n", - "Even when a circuit consists of commuting gates (this is the case for the QAOA circuit, but also for Trotterized simulations of Ising Hamiltonians), finding a good initial mapping is a challenging task. The SAT-based approach presented in [\\[2\\]](#references) enables the discovery of effective initial mappings for circuits with commuting gates, resulting in a significant reduction in the number of required SWAP layers. This approach has been demonstrated to scale to up to *500 qubits*, as illustrated in the paper.\n", + "Even when a circuit consists of commuting gates (this is the case for the QAOA circuit, but also for Trotterized simulations of Ising Hamiltonians), finding a good initial mapping is a challenging task. When we use the SAT-based approach presented in [\\[2\\]](#references), we can discover effective initial mappings for circuits with commuting gates, resulting in a significant reduction in the number of required SWAP layers. This approach has been demonstrated to scale to up to *500 qubits*, as illustrated in the paper.\n", "\n", "The following code demonstrates how to use the `SATMapper` from Matsuo et al. to remap the graph. This process allows the problem to be mapped to a more optimal initial state for a specified SWAP strategy, resulting in a significant reduction in the number of SWAP layers required to execute the circuit.\n", "\n", @@ -608,7 +656,7 @@ "We only want to apply the SWAP strategies to the cost operator layer, so we start by creating the isolated block that we will later transform and append to the final QAOA circuit.\n", "\n", "For this, we can use the [`QAOAAnsatz`](/docs/api/qiskit/qiskit.circuit.library.QAOAAnsatz) class from Qiskit. We input an empty circuit to the `initial_state` and `mixer_operator` fields to make sure we are building an isolated cost operator layer.\n", - "We also define the edge_coloring map so that RZZ gates are positioned next to SWAP gates. This strategic placement allows us to exploit CX cancellations, optimizing the circuit for better performance.\n", + "We also define the `edge_coloring` map so that RZZ gates are positioned next to SWAP gates. This strategic placement allows us to exploit CX cancellations, optimizing the circuit for better performance.\n", "This process is executed within the `create_qaoa_swap_circuit` function." ] }, @@ -813,14 +861,6 @@ "id": "82ae28b3-85eb-4487-8100-1e622e93cccf", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/mirko/Workspace/documentation/.venv/lib/python3.13/site-packages/qiskit/circuit/quantumcircuit.py:4625: UserWarning: Trying to add QuantumRegister to a QuantumCircuit having a layout\n", - " circ.add_register(qreg)\n" - ] - }, { "data": { "text/plain": [ @@ -847,11 +887,9 @@ "id": "e2afd1a7-0980-433b-a3a8-303d7e7718b1", "metadata": {}, "source": [ - "## Step 3: Execute using Qiskit primitives\n", + "## Step 3: Execute using Qiskit Runtime primitives\n", "\n", - "### Define a CVaR cost function\n", - "\n", - "This example shows how to use the Conditional Value at Risk (CVaR) cost function introduced in [\\[3\\]](#references) within the variational quantum optimization algorithms.\n", + "Let's now prepare for hardware execution. Our first step will be to define a Conditional Value at Risk (CVaR) cost function, which was introduced in [\\[3\\]](#references) for use within the paradigm of variational quantum optimization algorithms.\n", "\n", "The CVaR of a random variable $X$ for a confidence level $α ∈ (0, 1]$ is defined as\n", "$CVaR_{\\alpha}(X) = \\mathbb{E} \\lbrack X | X \\leq F_X^{-1}(\\alpha) \\rbrack$\n", @@ -1026,7 +1064,7 @@ "id": "63fa2ab4-5354-4022-ab46-e9bbf73870de", "metadata": {}, "source": [ - "The CVaR can be used as an error mitigation technique as previously discussed [\\[4\\]](#references). In this example, we determine $\\alpha$ and the number of shots according to the circuit's error rate." + "The CVaR can be used as an error mitigation technique as previously discussed [\\[4\\]](#references). In this example, we determine $\\alpha$ and the number of shots according to the [error per layered gate](/docs/guides/qpu-information#2q-error-layered) (EPLG) associated with the circuit." ] }, { @@ -1073,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": null, "id": "382e8acd-d0d0-4302-99aa-b64e5dd31e17", "metadata": {}, "outputs": [ @@ -1127,6 +1165,9 @@ " sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n", " sampler.options.twirling.enable_gates = True\n", " sampler.options.twirling.enable_measure = True\n", + " sampler.options.environment.job_tags = [\n", + " \"TUT_AQAOA\"\n", + " ] # add tag for your job execution\n", "\n", " result = minimize(\n", " qaoa_sampler_cost_fun,\n", @@ -1148,7 +1189,9 @@ "id": "1d190fa4-3bbe-412a-b296-6dddd3ad2b12", "metadata": {}, "source": [ - "## Step 4: Post-process and return result in desired classical format" + "## Step 4: Post-process and return result in desired classical format\n", + "\n", + "Let's now visualize our results and then post-process them to find the value of the cut." ] }, { @@ -1190,12 +1233,12 @@ "id": "38aadfcb-aec9-4dbb-a9d3-319239eae196", "metadata": {}, "source": [ - "The following retrieves the best solution from the sampled bitstrings" + "The following retrieves the best solution from the sampled bitstrings:" ] }, { "cell_type": "code", - "execution_count": 112, + "execution_count": null, "id": "7e8af29e-c99b-41f2-b6dd-2be471e1af21", "metadata": {}, "outputs": [ @@ -1208,7 +1251,7 @@ } ], "source": [ - "# sort the result_dict[iter_counts]['evaluated'] by the CVaR value\n", + "# Sort the result_dict[iter_counts]['evaluated'] by the CVaR value\n", "sorted_result_dict = [\n", " (k, v)\n", " for k, v in sorted(\n", @@ -1229,10 +1272,10 @@ "Consider the Hamiltonian $H_C$ for the **Max-Cut** problem. Let each vertex of the graph be associated with a qubit in state $|0\\rangle$ or $|1\\rangle$, where the value denotes the set the vertex is in. The goal of the problem is to maximize the number of edges $(v_1, v_2)$ for which $v_1 = |0\\rangle$ and $v_2 = |1\\rangle$, or vice versa. If we associate the $Z$ operator with each qubit, where\n", "\n", "$$\n", - " Z|0\\rangle = |0\\rangle \\qquad Z|1\\rangle = -|1\\rangle\n", + " Z|0\\rangle = |0\\rangle \\qquad Z|1\\rangle = -|1\\rangle,\n", "$$\n", "\n", - "then an edge $(v_1, v_2)$ belongs to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = -1$; in other words, the qubits associated with $v_1$ and $v_2$ are different. Similarly, $(v_1, v_2)$ does not belong to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = 1$" + "then an edge $(v_1, v_2)$ belongs to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = -1$; in other words, the qubits associated with $v_1$ and $v_2$ are different. Similarly, $(v_1, v_2)$ does not belong to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = 1$." ] }, { @@ -1346,14 +1389,18 @@ }, { "cell_type": "markdown", - "id": "c048cd84-d6e8-4b8a-926e-a7f7724a86e2", + "id": "a6a5bbfe-a159-4dc1-9333-488737aff503", "metadata": {}, "source": [ - "## Tutorial survey\n", + "## Next steps\n", + "\n", + "\n", "\n", - "Please take one minute to provide feedback on this tutorial. Your insights will help us improve our content offerings and user experience.\n", + "If you found this work interesting, you might be interested in the following material:\n", "\n", - "[Link to survey](https://your.feedback.ibm.com/jfe/form/SV_cZwpScxyXVDpIeq)" + "* [The intractable decathlon](https://arxiv.org/pdf/2504.03832): a listing of 10 optimization problems that are difficult for classical optimization algorithms, and which may be good use cases to test the techniques introduced in this tutorial.\n", + "* [A repo of best practices for quantum optimization](https://github.com/qiskit-community/qopt-best-practices) to further improve the results of your QAOA-based workflow.\n", + "" ] } ], diff --git a/docs/tutorials/quantum-approximate-optimization-algorithm.ipynb b/docs/tutorials/quantum-approximate-optimization-algorithm.ipynb index 86a7338199b..c616e51ef67 100644 --- a/docs/tutorials/quantum-approximate-optimization-algorithm.ipynb +++ b/docs/tutorials/quantum-approximate-optimization-algorithm.ipynb @@ -2,29 +2,35 @@ "cells": [ { "cell_type": "markdown", - "id": "5d52815f", - "metadata": { - "tags": [ - "remove-cell" - ] - }, + "id": "bc51e7bf-e582-49ba-93f8-035624d56ccf", + "metadata": {}, "source": [ "---\n", - "title: Quantum approximate optimization algorithm\n", - "description: Learn the basics of quantum computing, and how to use IBM Quantum services and QPUs to solve real-world problems.\n", + "title: Quantum Approximate Optimization Algorithm\n", + "description: Solve Max-Cut using QAOA with Qiskit patterns at utility scale.\n", "---\n", "\n", + "# Quantum approximate optimization algorithm\n", "\n", - "{/* cspell:ignore rarr, QUBO, elist, fval, frameon */}" + "*Usage estimate: 22 minutes on a Heron r3 processor (NOTE: This is an estimate only. Your runtime might vary.)*\n" ] }, { "cell_type": "markdown", - "id": "bc51e7bf-e582-49ba-93f8-035624d56ccf", + "id": "learning-outcomes-prereqs", "metadata": {}, "source": [ - "# Quantum approximate optimization algorithm\n", - "*Usage estimate: 22 minutes on a Heron r3 processor (NOTE: This is an estimate only. Your runtime might vary.)*" + "## Learning outcomes\n", + "After completing this tutorial, you can expect to understand the following information:\n", + "- How to map a classical combinatorial optimization problem (Max-Cut) to a quantum Hamiltonian\n", + "- How to implement and run the Quantum Approximate Optimization Algorithm (QAOA) using Qiskit Runtime sessions\n", + "- How to scale a QAOA workflow from a small simulator example to utility-scale hardware execution\n", + "\n", + "## Prerequisites\n", + "It is recommended that you familiarize yourself with these topics:\n", + "- [Basics of quantum circuits](https://learning.quantum.ibm.com/course/basics-of-quantum-information)\n", + "- [Variational algorithms](https://learning.quantum.ibm.com/course/variational-algorithm-design)\n", + "- [QAOA in depth](https://learning.quantum.ibm.com/course/variational-algorithm-design/quantum-approximate-optimization-algorithm) — for a comprehensive treatment of the QAOA algorithm and its mathematical foundations\n" ] }, { @@ -33,12 +39,36 @@ "metadata": {}, "source": [ "## Background\n", - "This tutorial demonstrates how to implement the **Quantum Approximate Optimization Algorithm (QAOA)** – a hybrid (quantum-classical) iterative method – within the context of Qiskit patterns. You will first solve the **Maximum-Cut** (or **Max-Cut**) problem for a small graph and then learn how to execute it at utility scale. All the hardware executions in the tutorial should run within the time limit for the freely-accessible Open Plan.\n", "\n", + "The **Quantum Approximate Optimization Algorithm (QAOA)** is a hybrid quantum-classical iterative method for solving combinatorial optimization problems. In this tutorial, you will use QAOA to solve the **Maximum-Cut (Max-Cut)** problem — an NP-hard optimization problem with applications in clustering, network science, and statistical physics. Given a graph of nodes connected by edges, the goal is to partition the nodes into two sets such that the number of edges crossing the partition is maximized.\n", + "\n", + "![Illustration of a max-cut problem](https://quantum.cloud.ibm.com/docs/images/tutorials/quantum-approximate-optimization-algorithm/maxcut-illustration.avif)\n", "\n", - "The Max-Cut problem is an optimization problem that is hard to solve (more specifically, it is an *NP-hard* problem) with a number of different applications in clustering, network science, and statistical physics. This tutorial considers a graph of nodes connected by edges, and aims to partition the nodes into two sets such that the number of edges traversed by this cut is maximized.\n", + "### From classical optimization to quantum circuits\n", "\n", - "![Illustration of a max-cut problem](/docs/images/tutorials/quantum-approximate-optimization-algorithm/maxcut-illustration.avif)" + "Max-Cut can be expressed as a classical binary optimization problem. Each node is assigned a binary variable $x_i \\in \\{0, 1\\}$ indicating which set it belongs to. The objective is to maximize the number of edges where the endpoints are in different sets:\n", + "\n", + "$$\n", + "\\max_{x \\in \\{0,1\\}^n} \\sum_{(i,j)} x_i + x_j - 2x_ix_j.\n", + "$$\n", + "\n", + "This is equivalently a **Quadratic Unconstrained Binary Optimization (QUBO)** problem of the form $\\min_x\\, x^T Q x$. Through a standard variable substitution ($x_i \\to (1 - Z_i)/2$), the QUBO can be rewritten as a **cost Hamiltonian** whose ground state encodes the optimal solution. In general, this Hamiltonian has both quadratic and linear terms:\n", + "\n", + "$$\n", + "H_C = \\sum_{ij} Q_{ij} \\, Z_i Z_j + \\sum_i b_i \\, Z_i.\n", + "$$\n", + "\n", + "For the unweighted Max-Cut problem considered here the linear coefficients vanish ($b_i = 0$) and $Q_{ij} = 1$ for each edge, leaving the simpler form $H_C = \\sum_{(i,j) \\in E} Z_i Z_j$ that you will build in code below. The more general form above is what you would need to adapt this workflow to weighted graphs or other QUBO-expressible problems.\n", + "\n", + "### How QAOA works\n", + "\n", + "QAOA prepares candidate solutions by applying alternating layers of two operators to an initial superposition state $H^{\\otimes n}|0\\rangle$: the **cost operator** $e^{-i\\gamma_k H_C}$ and a **mixer operator** $e^{-i\\beta_k H_m}$. The angles $\\gamma_k$ and $\\beta_k$ are optimized in a classical feedback loop — the quantum computer evaluates the cost function, and a classical optimizer updates the parameters until convergence. This iterative loop runs within a Qiskit Runtime **session**, which keeps the quantum device reserved across iterations for lower latency.\n", + "\n", + "![Circuit diagram with QAOA layers](https://quantum.cloud.ibm.com/docs/images/tutorials/quantum-approximate-optimization-algorithm/circuit-diagram.svg)\n", + "\n", + "For a deeper treatment of QAOA theory, including the full QUBO-to-Hamiltonian derivation, see the [QAOA course module](https://learning.quantum.ibm.com/course/variational-algorithm-design/quantum-approximate-optimization-algorithm).\n", + "\n", + "In this tutorial you will first solve Max-Cut on a small 5-node graph, then scale the same workflow to a 100-node utility-scale problem on real hardware. Note on plan access. This tutorial uses Qiskit Runtime sessions, which are only available on the Premium Plan. If you are on the Open Plan, you cannot run this tutorial as written — you will need to swap `Session` for job mode (i.e. submit each iteration as an independent job rather than wrapping the optimization loop in with `Session(...)`). The workflow still runs, but each iteration incurs the full queue latency rather than reusing a reserved device.\n" ] }, { @@ -49,10 +79,11 @@ "## Requirements\n", "\n", "Before starting this tutorial, be sure you have the following installed:\n", - "- Qiskit SDK v1.0 or later, with [visualization](/docs/api/qiskit/visualization) support\n", - "- Qiskit Runtime v0.22 or later (`pip install qiskit-ibm-runtime`)\n", "\n", - "In addition, you will need access to an instance on [IBM Quantum Platform](/docs/guides/cloud-setup). Note that this tutorial cannot be executed on the Open Plan, because it runs workloads using [sessions](/docs/api/qiskit-ibm-runtime/session), which are only available with Premium Plan access." + "* Qiskit SDK v2.0 or later, with [visualization](/docs/api/qiskit/visualization) support\n", + "* Qiskit Runtime v0.22 or later (`pip install qiskit-ibm-runtime`)\n", + "\n", + "In addition, you will need access to an instance on [IBM Quantum Platform](/docs/guides/cloud-setup).\n" ] }, { @@ -60,7 +91,8 @@ "id": "f5307376", "metadata": {}, "source": [ - "## Setup" + "## Setup\n", + "\n" ] }, { @@ -70,7 +102,6 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import rustworkx as rx\n", "from rustworkx.visualization import mpl_draw as draw_graph\n", @@ -94,30 +125,9 @@ "id": "68fd0b4f-baa4-45dc-9f4c-d9cdff01a651", "metadata": {}, "source": [ - "## Part I. Small-scale QAOA\n", - "The first part of this tutorial uses a small-scale Max-Cut problem to illustrate the steps to solve an optimization problem using a quantum computer.\n", + "## Small-scale example\n", "\n", - "To give some context before mapping this problem to a quantum algorithm, you can better understand how the Max-Cut problem becomes a classical combinatorial optimization problem by first considering the minimization of a function $f(x)$\n", - "\n", - "$$\n", - "\\min_{x\\in \\{0, 1\\}^n}f(x),\n", - "$$\n", - "\n", - "where the input $x$ is a vector whose components correspond to each node of a graph. Then, constrain each of these components to be either $0$ or $1$ (which represent being included or not included in the cut). This small-scale example case uses a graph with $n=5$ nodes.\n", - "\n", - "You could write a function of a pair of nodes $i,j$ which indicates whether the corresponding edge $(i,j)$ is in the cut. For example, the function $x_i + x_j - 2 x_i x_j$ is 1 only if one of either $x_i$ or $x_j$ are 1 (which means that the edge is in the cut) and zero otherwise. The problem of maximizing the edges in the cut can be formulated as\n", - "\n", - "$$\n", - "\\max_{x\\in \\{0, 1\\}^n} \\sum_{(i,j)} x_i + x_j - 2 x_i x_j,\n", - "$$\n", - "\n", - "which can be rewritten as a minimization of the form\n", - "\n", - "$$\n", - "\\min_{x\\in \\{0, 1\\}^n} \\sum_{(i,j)} 2 x_i x_j - x_i - x_j.\n", - "$$\n", - "\n", - "The minimum of $f(x)$ in this case is when the number of edges traversed by the cut is maximal. As you can see, there is nothing relating to quantum computing yet. You need to reformulate this problem into something that a quantum computer can understand." + "This section walks through each step of the QAOA workflow on a small 5-node Max-Cut instance. Despite the \"small-scale\" label, this example still runs on real IBM Quantum hardware — the code selects a 127+ qubit backend and executes the circuit there.\n" ] }, { @@ -125,7 +135,8 @@ "id": "0cbca6cb", "metadata": {}, "source": [ - "Initialize your problem by creating a graph with $n=5$ nodes." + "Initialize your problem by creating a graph with $n=5$ nodes.\n", + "\n" ] }, { @@ -136,8 +147,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -145,10 +157,10 @@ } ], "source": [ - "n = 5\n", + "n_small = 5\n", "\n", "graph = rx.PyGraph()\n", - "graph.add_nodes_from(np.arange(0, n, 1))\n", + "graph.add_nodes_from(np.arange(0, n_small, 1))\n", "edge_list = [\n", " (0, 1, 1.0),\n", " (0, 2, 1.0),\n", @@ -168,38 +180,7 @@ "source": [ "### Step 1: Map classical inputs to a quantum problem\n", "\n", - "The first step of the pattern is to map the classical problem (graph) into quantum **circuits** and **operators**. To do this, there are three main steps to take:\n", - "\n", - "1. Utilize a series of mathematical reformulations, to represent this problem using the Quadratic Unconstrained Binary Optimization (QUBO) problems notation.\n", - "2. Rewrite the optimization problem as a Hamiltonian for which the ground state corresponds to the solution which minimizes the cost function.\n", - "3. Create a quantum circuit which will prepare the ground state of this Hamiltonian via a process similar to quantum annealing.\n", - "\n", - "\n", - "\n", - "**Note:** In the QAOA methodology, you ultimately want to have an operator (**Hamiltonian**) that represents the **cost function** of our hybrid algorithm, as well as a parametrized circuit (**Ansatz**) that represents quantum states with candidate solutions to the problem. You can sample from these candidate states and then evaluate them using the cost function.\n", - "\n", - "\n", - "#### Graph → optimization problem\n", - "\n", - "The first step of the mapping is a notation change, The following expresses the problem in QUBO notation:\n", - "\n", - "$$\n", - "\\min_{x\\in \\{0, 1\\}^n}x^T Q x,\n", - "$$\n", - "\n", - "where $Q$ is a $n\\times n$ matrix of real numbers, $n$ corresponds to the number of nodes in your graph, $x$ is the vector of binary variables introduced above, and $x^T$ indicates the transpose of the vector $x$.\n", - "\n", - "```\n", - "Maximize\n", - " -2*x_0*x_1 - 2*x_0*x_2 - 2*x_0*x_4 - 2*x_1*x_2 - 2*x_2*x_3 - 2*x_3*x_4 + 3*x_0\n", - " + 2*x_1 + 3*x_2 + 2*x_3 + 2*x_4\n", - "\n", - "Subject to\n", - " No constraints\n", - "\n", - " Binary variables (5)\n", - " x_0 x_1 x_2 x_3 x_4\n", - "```" + "Map the classical graph into quantum **circuits** and **operators**. As described in the [Background](#Background), for unweighted Max-Cut the cost Hamiltonian reduces to $H_C = \\sum_{(i,j) \\in E} Z_i Z_j$, and QAOA uses a parametrized ansatz circuit to prepare candidate ground states of $H_C$.\n" ] }, { @@ -207,80 +188,14 @@ "id": "a5b9e551-38a1-4543-b9f1-caaefb0ef3a9", "metadata": {}, "source": [ - "### Optimization problem → Hamiltonian\n", - "\n", - "You can then reformulate the QUBO problem as a **Hamiltonian** (here, a matrix that represents the energy of a system):\n", - "\n", - "$$\n", - "H_C=\\sum_{ij}Q_{ij}Z_iZ_j + \\sum_i b_iZ_i.\n", - "$$\n", - "\n", - "\n", - "\n", - "\n", - "To demonstrate how the QAOA problem can be rewritten in this way, first replace the binary variables $x_i$ to a new set of variables $z_i\\in\\{-1, 1\\}$ via\n", - "\n", - "$$\n", - "x_i = \\frac{1-z_i}{2}.\n", - "$$\n", - "\n", - "Here you can see that if $x_i$ is $0$, then $z_i$ must be $1$. When the $x_i$'s are substituted for the $z_i$'s in the optimization problem ($x^TQx$), an equivalent formulation can be obtained.\n", - "\n", - "$$\n", - "x^TQx=\\sum_{ij}Q_{ij}x_ix_j \\\\ =\\frac{1}{4}\\sum_{ij}Q_{ij}(1-z_i)(1-z_j) \\\\=\\frac{1}{4}\\sum_{ij}Q_{ij}z_iz_j-\\frac{1}{4}\\sum_{ij}(Q_{ij}+Q_{ji})z_i + \\frac{n^2}{4}.\n", - "$$\n", - "\n", - "Now if we define $b_i=-\\sum_{j}(Q_{ij}+Q_{ji})$, remove the prefactor, and the constant $n^2$ term, we arrive at the two equivalent formulations of the same optimization problem.\n", - "\n", - "$$\n", - "\\min_{x\\in\\{0,1\\}^n} x^TQx\\Longleftrightarrow \\min_{z\\in\\{-1,1\\}^n}z^TQz + b^Tz\n", - "$$\n", - "\n", - "Here, $b$ depends on $Q$. Note that to obtain $z^TQz + b^Tz$ we dropped the factor of 1/4 and a constant offset of $n^2$ which do not play a role in the optimization.\n", - "\n", - "\n", - "Now, to obtain a quantum formulation of the problem, promote the $z_i$ variables to a Pauli $Z$ matrix, such as a $2\\times 2$ matrix of the form\n", - "\n", - "$$\n", - "Z_i = \\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}.\n", - "$$\n", - "\n", - "When you substitute these matrices in the optimization problem above, you obtain the following Hamiltonian\n", - "\n", - "$$\n", - "H_C=\\sum_{ij}Q_{ij}Z_iZ_j + \\sum_i b_iZ_i.\n", - "$$\n", - "\n", - "*Also recall that the $Z$ matrices are embedded in the quantum computer's computational space, that is, a Hilbert space of size $2^n\\times 2^n$. Therefore, you should understand terms such as $Z_iZ_j$ as the tensor product $Z_i\\otimes Z_j$ embedded in the $2^n\\times 2^n$ Hilbert space. For example, in a problem with five decision variables the term $Z_1Z_3$ is understood to mean $I\\otimes Z_3\\otimes I\\otimes Z_1\\otimes I$ where $I$ is the $2\\times 2$ identity matrix.*\n", - " \n", - "\n", - "\n", - "This Hamiltonian is called the **cost function Hamiltonian**. It has the property that its ground state corresponds to the solution that **minimizes the cost function $f(x)$**.\n", - "Therefore, to solve your optimization problem you now need to prepare the ground state of $H_C$ (or a state with a high overlap with it) on the quantum computer. Then, sampling from this state will, with a high probability, yield the solution to $min~f(x)$." - ] - }, - { - "cell_type": "markdown", - "id": "183f3603-1e5d-4839-a23c-31d17f5489a0", - "metadata": {}, - "source": [ - "Now let us consider the Hamiltonian $H_C$ for the **Max-Cut** problem. Let each vertex of the graph be associated with a qubit in state $|0\\rangle$ or $|1\\rangle$, where the value denotes the set the vertex is in. The goal of the problem is to maximize the number of edges $(v_1, v_2)$ for which $v_1 = |0\\rangle$ and $v_2 = |1\\rangle$, or vice-versa. If we associate the $Z$ operator with each qubit, where\n", + "#### Build the cost Hamiltonian\n", "\n", - "$$\n", - " Z|0\\rangle = |0\\rangle \\qquad Z|1\\rangle = -|1\\rangle\n", - "$$\n", - "\n", - "then an edge $(v_1, v_2)$ belongs to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = -1$; in other words, the qubits associated with $v_1$ and $v_2$ are different. Similarly, $(v_1, v_2)$ does not belong to the cut if the eigenvalue of $(Z_1|v_1\\rangle) \\cdot (Z_2|v_2\\rangle) = 1$. Note that, we do not care about the exact qubit state associated with each vertex, rather we care only whether they are same or not across an edge. The Max-Cut problem requires us to find an assignment of the qubits on the vertices such that the eigenvalue of the following Hamiltonian is minimized\n", - "$$\n", - " H_C = \\sum_{(i,j) \\in e} Q_{ij} \\cdot Z_i Z_j.\n", - "$$\n", - "\n", - "In other words, $b_i = 0$ for all $i$ in the Max-Cut problem. The value of $Q_{ij}$ denotes the weight of the edge. In this tutorial we consider an unweighted graph, that is, $Q_{ij} = 1.0$ for all $i, j$." + "Convert the graph edges into Pauli $Z_iZ_j$ terms to construct $H_C$ (see [Background](#Background) for the derivation).\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "52d1ba92", "metadata": {}, "outputs": [ @@ -297,9 +212,11 @@ "def build_max_cut_paulis(\n", " graph: rx.PyGraph,\n", ") -> list[tuple[str, list[int], float]]:\n", - " \"\"\"Convert the graph to Pauli list.\n", + " \"\"\"Convert graph edges to a list of ZZ Pauli terms.\n", "\n", - " This function does the inverse of `build_max_cut_graph`\n", + " The returned list is in the sparse format expected by\n", + " ``SparsePauliOp.from_sparse_list``: each element is\n", + " ``(pauli_string, qubit_indices, coefficient)``.\n", " \"\"\"\n", " pauli_list = []\n", " for edge in list(graph.edge_list()):\n", @@ -309,7 +226,7 @@ "\n", "\n", "max_cut_paulis = build_max_cut_paulis(graph)\n", - "cost_hamiltonian = SparsePauliOp.from_sparse_list(max_cut_paulis, n)\n", + "cost_hamiltonian = SparsePauliOp.from_sparse_list(max_cut_paulis, n_small)\n", "print(\"Cost Function Hamiltonian:\", cost_hamiltonian)" ] }, @@ -318,7 +235,7 @@ "id": "33f71b0d-4a2a-4082-8c1a-ce9d2b769048", "metadata": {}, "source": [ - "#### Hamiltonian → quantum circuit" + "#### Build the QAOA ansatz circuit\n" ] }, { @@ -326,17 +243,7 @@ "id": "00431c46-30c2-40f9-99df-40baf8da98f6", "metadata": {}, "source": [ - "The Hamiltonian $H_C$ contains the quantum definition of your problem. Now you can create a quantum circuit that will help *sample* good solutions from the quantum computer. The QAOA is inspired by quantum annealing and applies alternating layers of operators in the quantum circuit.\n", - "\n", - "The general idea is to start in the ground state of a known system, $H^{\\otimes n}|0\\rangle$ above, and then steer the system into the ground state of the cost operator that you are interested in. This is done by applying the operators $\\exp\\{-i\\gamma_k H_C\\}$ and $\\exp\\{-i\\beta_k H_m\\}$ with angles $\\gamma_1,...,\\gamma_p$ and $\\beta_1,...,\\beta_p~$.\n", - "\n", - "\n", - "The quantum circuit that you generate is **parametrized** by $\\gamma_i$ and $\\beta_i$, so you can try out different values of $\\gamma_i$ and $\\beta_i$ and sample from the resulting state.\n", - "\n", - "![Circuit diagram with QAOA layers](/docs/images/tutorials/quantum-approximate-optimization-algorithm/circuit-diagram.svg)\n", - "\n", - "\n", - "In this case, you will try an example with one QAOA layer that contains two parameters: $\\gamma_1$ and $\\beta_1$." + "Use `QAOAAnsatz` to construct the parametrized QAOA circuit from the cost Hamiltonian. Here we use `reps=2` (two QAOA layers, four parameters: $\\beta_0, \\beta_1, \\gamma_0, \\gamma_1$).\n" ] }, { @@ -347,8 +254,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "execution_count": 4, @@ -389,7 +297,8 @@ "id": "82f70daa-ff68-447a-8064-8b7df7a646cf", "metadata": {}, "source": [ - "### Step 2: Optimize problem for quantum hardware execution" + "### Step 2: Optimize problem for quantum hardware execution\n", + "\n" ] }, { @@ -397,21 +306,7 @@ "id": "c08be444-e3ed-4178-a10b-414069b1b411", "metadata": {}, "source": [ - "The circuit above contains a series of abstractions useful to think about quantum algorithms, but not possible to run on the hardware. To be able to run on a QPU, the circuit needs to undergo a series of operations that make up the **transpilation** or **circuit optimization** step of the pattern.\n", - "\n", - "The Qiskit library offers a series of **transpilation passes** that cater to a wide range of circuit transformations. You need to make sure that your circuit is **optimized** for your purpose.\n", - "\n", - "Transpilation may involves several steps, such as:\n", - "\n", - "* **Initial mapping** of the qubits in the circuit (such as decision variables) to physical qubits on the device.\n", - "* **Unrolling** of the instructions in the quantum circuit to the hardware-native instructions that the backend understands.\n", - "* **Routing** of any qubits in the circuit that interact to physical qubits that are adjacent with one another.\n", - "* **Error suppression** by adding single-qubit gates to suppress noise with dynamical decoupling.\n", - "\n", - "\n", - "More information about transpilation is available in our [documentation](/docs/guides/transpile).\n", - "\n", - "The following code transforms and optimizes the abstract circuit into a format that is ready for execution on one of devices accessible through the cloud using the **Qiskit IBM Runtime service**." + "Transpile the abstract circuit into hardware-native instructions. This step handles qubit mapping, gate decomposition, routing, and error suppression. More information about transpilation is available in our [documentation](/docs/guides/transpile).\n" ] }, { @@ -424,13 +319,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "execution_count": 6, @@ -445,7 +341,9 @@ ")\n", "print(backend)\n", "\n", - "# Create pass manager for transpilation\n", + "# Create pass manager for transpilation. Level 3 is the most aggressive\n", + "# preset: slower to transpile, but produces shorter circuits that are\n", + "# more robust to hardware noise.\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", "\n", "candidate_circuit = pm.run(circuit)\n", @@ -457,7 +355,8 @@ "id": "4e75cad7-f599-4937-b5fe-f4d01f53423c", "metadata": {}, "source": [ - "### Step 3: Execute using Qiskit primitives" + "### Step 3: Execute using Qiskit primitives\n", + "\n" ] }, { @@ -465,11 +364,9 @@ "id": "9b99ce67-f121-4244-b62a-536be38fea86", "metadata": {}, "source": [ - "In the QAOA workflow, the optimal QAOA parameters are found in an iterative optimization loop, which runs a series of circuit evaluations and uses a classical optimizer to find the optimal $\\beta_k$ and $\\gamma_k$ parameters. This execution loop is executed via the following steps:\n", + "The QAOA optimization loop runs inside a Qiskit Runtime [session](/docs/guides/execution-modes) to keep the device reserved across iterations. An Estimator evaluates $\\langle H_C \\rangle$ at each step, and a classical optimizer (COBYLA) updates the parameters until convergence.\n", "\n", - "1. Define the initial parameters\n", - "2. Instantiate a new `Session` containing the optimization loop and the primitive used to sample the circuit\n", - "3. Once an optimal set of parameters is found, execute the circuit a final time to obtain a final distribution which will be used in the post-process step." + "![Illustration showing the behavior of Single job, Batch, and Session runtime modes.](https://quantum.cloud.ibm.com/docs/images/tutorials/quantum-approximate-optimization-algorithm/runtime-modes.avif)\n" ] }, { @@ -477,8 +374,7 @@ "id": "00b2b0f1-9bad-4ad3-b93e-5cbf40395dbf", "metadata": {}, "source": [ - "#### Define circuit with initial parameters\n", - "We start with arbitrary chosen parameters." + "Define initial parameters and run the optimization loop:\n" ] }, { @@ -488,34 +384,17 @@ "metadata": {}, "outputs": [], "source": [ + "# QAOA doesn't prescribe principled default angles — any bounded choice\n", + "# works as a warm start for problems this small. beta and gamma are\n", + "# periodic (beta in [0, pi] and gamma in [0, 2*pi] modulo the underlying\n", + "# Pauli-rotation periods), and pi/2 and pi are just midpoints of those\n", + "# ranges. For harder problems you would typically warm start from known\n", + "# good angles or transfer parameters from smaller instances.\n", "initial_gamma = np.pi\n", "initial_beta = np.pi / 2\n", "init_params = [initial_beta, initial_beta, initial_gamma, initial_gamma]" ] }, - { - "cell_type": "markdown", - "id": "b867f1b0-7196-4d34-9b28-e3fb1de8221c", - "metadata": {}, - "source": [ - "#### Define backend and execution primitive\n", - "Use the **Qiskit Runtime primitives** to interact with IBM® backends. The two primitives are Sampler and Estimator, and the choice of primitive depends on what type of measurement you want to run on the quantum computer. For the minimization of $H_C$, use the Estimator since the measurement of the cost function is simply the expectation value of $\\langle H_C \\rangle$." - ] - }, - { - "cell_type": "markdown", - "id": "ebe288e7-ce87-4b6d-949c-041db09c7c47", - "metadata": {}, - "source": [ - "#### Run\n", - "\n", - "The primitives offer a variety of [execution modes](/docs/guides/execution-modes) to schedule workloads on quantum devices, and a QAOA workflow runs iteratively in a session.\n", - "\n", - "![Illustration showing the behavior of Single job, Batch, and Session runtime modes.](/docs/images/tutorials/quantum-approximate-optimization-algorithm/runtime-modes.avif)\n", - "\n", - "You can plug the sampler-based cost function into the SciPy minimizing routine to find the optimal parameters." - ] - }, { "cell_type": "code", "execution_count": 8, @@ -552,9 +431,9 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -1.6295230263157894\n", - " x: [ 1.530e+00 1.439e+00 4.071e+00 4.434e+00]\n", - " nfev: 26\n", + " fun: -2.0402211719947774\n", + " x: [ 3.041e+00 1.212e+00 2.081e+00 4.471e+00]\n", + " nfev: 36\n", " maxcv: 0.0\n" ] } @@ -571,6 +450,7 @@ " estimator.options.dynamical_decoupling.sequence_type = \"XY4\"\n", " estimator.options.twirling.enable_gates = True\n", " estimator.options.twirling.num_randomizations = \"auto\"\n", + " estimator.options.environment.job_tags = [\"TUT_QAOA\"]\n", "\n", " result = minimize(\n", " cost_func_estimator,\n", @@ -587,7 +467,10 @@ "id": "01d6b81c", "metadata": {}, "source": [ - "The optimizer was able to reduce the cost and find better parameters for the circuit." + "The optimizer was able to reduce the cost and find better parameters for the circuit.\n", + "\n", + "A smoothly decreasing curve that plateaus is the signature of convergence. A noisy, non-monotonic curve usually indicates that something upstream needs attention — common causes are too few shots per evaluation (high estimator variance), poor initial parameters, or a circuit whose depth is dominated by hardware noise. COBYLA is derivative-free and fairly robust to moderate noise, but when the noise swamps the actual cost improvements per step, its linear-approximation model can no longer tell real descent from random jitter and the optimizer wanders.\n", + "\n" ] }, { @@ -598,8 +481,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -619,9 +503,7 @@ "id": "1f9c8a9c", "metadata": {}, "source": [ - "Once you have found the optimal parameters for the circuit, you can assign these parameters and sample the final distribution obtained with the optimized parameters. Here is where the *Sampler* primitive should be used since it is the probability distribution of bitstring measurements which correspond to the optimal cut of the graph.\n", - "\n", - "**Note:** This means preparing a quantum state $\\psi$ in the computer and then measuring it. A measurement will collapse the state into a single computational basis state - for example, `010101110000...` - which corresponds to a candidate solution $x$ to our initial optimization problem ($\\max f(x)$ or $\\min f(x)$ depending on the task)." + "Assign the optimized parameters and sample the final distribution using the Sampler primitive.\n" ] }, { @@ -632,8 +514,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "execution_count": 11, @@ -656,7 +539,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{28: 0.0328, 11: 0.0343, 2: 0.0296, 25: 0.0308, 16: 0.0303, 27: 0.0302, 13: 0.0323, 7: 0.0312, 4: 0.0296, 9: 0.0295, 26: 0.0321, 30: 0.031, 23: 0.0324, 31: 0.0303, 21: 0.0335, 15: 0.0317, 12: 0.0309, 29: 0.0297, 3: 0.0313, 5: 0.0312, 6: 0.0274, 10: 0.0329, 22: 0.0353, 0: 0.0315, 20: 0.0326, 8: 0.0322, 14: 0.0306, 17: 0.0295, 18: 0.0279, 1: 0.0325, 24: 0.0334, 19: 0.0295}\n" + "{18: 0.039, 5: 0.0665, 20: 0.0973, 29: 0.0063, 9: 0.0899, 13: 0.0379, 2: 0.0047, 1: 0.0153, 11: 0.0932, 14: 0.0327, 12: 0.0314, 25: 0.0193, 21: 0.0398, 6: 0.0224, 4: 0.0197, 10: 0.0387, 3: 0.0181, 26: 0.07, 17: 0.0327, 19: 0.0332, 22: 0.0914, 24: 0.007, 0: 0.0033, 8: 0.0066, 30: 0.0158, 28: 0.0169, 27: 0.0222, 16: 0.0073, 7: 0.0057, 23: 0.0062, 15: 0.0054, 31: 0.0041}\n" ] } ], @@ -671,6 +554,8 @@ "sampler.options.twirling.enable_gates = True\n", "sampler.options.twirling.num_randomizations = \"auto\"\n", "\n", + "sampler.options.environment.job_tags = [\"TUT_QAOA\"]\n", + "\n", "pub = (optimized_circuit,)\n", "job = sampler.run([pub], shots=int(1e4))\n", "counts_int = job.result()[0].data.meas.get_int_counts()\n", @@ -688,7 +573,7 @@ "source": [ "### Step 4: Post-process and return result in desired classical format\n", "\n", - "The post-processing step interprets the sampling output to return a solution for your original problem. In this case, you are interested in the bitstring with the highest probability as this determines the optimal cut. The symmetries in the problem allow for four possible solutions, and the sampling process will return one of them with a slightly higher probability, but you can see in the plotted distribution below that four of the bitstrings are distinctively more likely than the rest." + "Extract the most likely bitstring from the sampled distribution — this represents the best cut found by QAOA.\n" ] }, { @@ -701,7 +586,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Result bitstring: [0, 1, 1, 0, 1]\n" + "Result bitstring: [0, 0, 1, 0, 1]\n" ] } ], @@ -729,8 +614,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -738,7 +624,7 @@ } ], "source": [ - "matplotlib.rcParams.update({\"font.size\": 10})\n", + "plt.rcParams.update({\"font.size\": 10})\n", "final_bits = final_distribution_bin\n", "values = np.abs(list(final_bits.values()))\n", "top_4_values = sorted(values, reverse=True)[:4]\n", @@ -764,7 +650,8 @@ "source": [ "#### Visualize best cut\n", "\n", - "From the optimal bit string, you can then visualize this cut on the original graph." + "From the optimal bit string, you can then visualize this cut on the original graph.\n", + "\n" ] }, { @@ -775,8 +662,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -801,7 +689,8 @@ "id": "2119575f-f3cf-45bc-ae2b-93c046391eb6", "metadata": {}, "source": [ - "And calculate the value of the cut:" + "And calculate the value of the cut:\n", + "\n" ] }, { @@ -835,200 +724,207 @@ }, { "cell_type": "markdown", - "id": "2e2a89de-cef3-46ea-b201-cf931b65dfea", + "id": "76a7241e", "metadata": {}, "source": [ - "## Part II. Scale it up!\n", - "\n", - "You have access to many devices with over 100 qubits on IBM Quantum® Platform. Select one on which to solve Max-Cut on a 100-node weighted graph. This is a \"utility-scale\" problem. The steps to build the workflow are followed the same as above, but with a much larger graph." + "For a graph this small the true optimum is easy to brute-force, so you can compare the QAOA result against the exact answer as a sanity check.\n" ] }, { "cell_type": "code", "execution_count": 17, - "id": "590fe2ce", + "id": "0a3b5267", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "\"Output" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Classical optimum (brute force): 5\n", + "QAOA cut value: 5\n" + ] } ], "source": [ - "n = 100 # Number of nodes in graph\n", - "graph_100 = rx.PyGraph()\n", - "graph_100.add_nodes_from(np.arange(0, n, 1))\n", - "elist = []\n", - "for edge in backend.coupling_map:\n", - " if edge[0] < n and edge[1] < n:\n", - " elist.append((edge[0], edge[1], 1.0))\n", - "graph_100.add_edges_from(elist)\n", - "draw_graph(graph_100, node_size=200, with_labels=True, width=1)" + "# Classical baseline: enumerate all 2**n_small bitstrings and take the best cut.\n", + "def brute_force_max_cut(graph: rx.PyGraph) -> tuple[int, list[int]]:\n", + " n = len(list(graph.nodes()))\n", + " best_cut = -1\n", + " best_x: list[int] = []\n", + " for i in range(2**n):\n", + " x = [(i >> k) & 1 for k in range(n)]\n", + " cut = evaluate_sample(x, graph)\n", + " if cut > best_cut:\n", + " best_cut = int(cut)\n", + " best_x = x\n", + " return best_cut, best_x\n", + "\n", + "\n", + "classical_best, classical_x = brute_force_max_cut(graph)\n", + "print(f\"Classical optimum (brute force): {classical_best}\")\n", + "print(f\"QAOA cut value: {cut_value}\")\n" ] }, { "cell_type": "markdown", - "id": "31bb3bc1-f19e-4553-9e93-a89e92ea5469", + "id": "large-scale-header", "metadata": {}, "source": [ - "### Step 1: Map classical inputs to a quantum problem" + "## Large-scale hardware example\n", + "\n", + "You have access to many devices with over 100 qubits on IBM Quantum® Platform. Select one on which to solve Max-Cut on a 100-node weighted graph. This is a \"utility-scale\" problem. The workflow follows the same steps as above, applied to a much larger graph.\n" ] }, { "cell_type": "markdown", - "id": "3dacef1f", + "id": "large-scale-steps-intro", "metadata": {}, "source": [ - "#### Graph → Hamiltonian\n", - "First, convert the graph you want to solve directly into a Hamiltonian that is suited for QAOA." + "### End-to-end workflow at utility scale\n", + "\n", + "All four steps are shown below, applied to the 100-node graph. The structure is the same as the small-scale walkthrough — map, transpile, execute, post-process — just with a larger problem and split across the four cells below for clarity.\n" ] }, { "cell_type": "code", "execution_count": 18, - "id": "a6bdceed", + "id": "large-scale-helpers", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cost Function Hamiltonian: SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIZIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIZIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIZIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIZIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIZIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIZIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'],\n", - " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,\n", - " 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" - ] - } - ], + "outputs": [], "source": [ - "max_cut_paulis_100 = build_max_cut_paulis(graph_100)\n", + "# Precomputed parity lookup table: _PARITY[b] = +1 if popcount(b) is even, else -1.\n", + "# We use this to vectorize expectation-value evaluation across all Pauli terms.\n", + "_PARITY = np.array(\n", + " [-1 if bin(i).count(\"1\") % 2 else 1 for i in range(256)],\n", + " dtype=np.complex128,\n", + ")\n", + "\n", + "\n", + "def evaluate_sparse_pauli(state: int, observable: SparsePauliOp) -> complex:\n", + " \"\"\"Expectation value of a SparsePauliOp on a single computational-basis state.\n", + "\n", + " For a Z-only observable (which QAOA cost Hamiltonians are, after the\n", + " QUBO-to-Hamiltonian mapping), the eigenvalue of each Pauli term on a\n", + " computational-basis state is simply (-1)**popcount(z_mask AND state),\n", + " i.e. the parity of the bitwise-AND of the term's Z-support and the\n", + " measured bitstring.\n", + "\n", + " This routine packs the Z-support of every Pauli term into bytes, ANDs\n", + " them against the measured state in a single vectorized op, and looks up\n", + " the parity in _PARITY. For a 100-qubit / ~hundreds-of-terms Hamiltonian\n", + " over 10_000 samples, this is dramatically faster than calling\n", + " SparsePauliOp.expectation_value per sample.\n", + " \"\"\"\n", + " packed_uint8 = np.packbits(observable.paulis.z, axis=1, bitorder=\"little\")\n", + " state_bytes = np.frombuffer(\n", + " state.to_bytes(packed_uint8.shape[1], \"little\"), dtype=np.uint8\n", + " )\n", + " reduced = np.bitwise_xor.reduce(packed_uint8 & state_bytes, axis=1)\n", + " return np.sum(observable.coeffs * _PARITY[reduced])\n", + "\n", + "\n", + "def best_solution(samples, hamiltonian):\n", + " \"\"\"Return the sampled bitstring (as int) with the lowest Hamiltonian cost.\"\"\"\n", + " min_cost = float(\"inf\")\n", + " min_sol = None\n", + " for bit_str in samples.keys():\n", + " candidate_sol = int(bit_str)\n", + " fval = evaluate_sparse_pauli(candidate_sol, hamiltonian).real\n", + " if fval <= min_cost:\n", + " min_cost = fval\n", + " min_sol = candidate_sol\n", + " return min_sol\n", "\n", - "cost_hamiltonian_100 = SparsePauliOp.from_sparse_list(max_cut_paulis_100, 100)\n", - "print(\"Cost Function Hamiltonian:\", cost_hamiltonian_100)" + "\n", + "def _plot_cdf(objective_values: dict, ax, color):\n", + " x_vals = sorted(objective_values.keys(), reverse=True)\n", + " y_vals = np.cumsum([objective_values[x] for x in x_vals])\n", + " ax.plot(x_vals, y_vals, color=color)\n", + "\n", + "\n", + "def plot_cdf(dist, ax, title):\n", + " _plot_cdf(dist, ax, \"C1\")\n", + " ax.vlines(min(list(dist.keys())), 0, 1, \"C1\", linestyle=\"--\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"Objective function value\")\n", + " ax.set_ylabel(\"Cumulative distribution function\")\n", + " ax.grid(alpha=0.3)\n", + "\n", + "\n", + "def samples_to_objective_values(samples, hamiltonian):\n", + " \"\"\"Convert the samples to values of the objective function.\"\"\"\n", + " objective_values = defaultdict(float)\n", + " for bit_str, prob in samples.items():\n", + " candidate_sol = int(bit_str)\n", + " fval = evaluate_sparse_pauli(candidate_sol, hamiltonian).real\n", + " objective_values[fval] += prob\n", + " return objective_values\n" ] }, { "cell_type": "markdown", - "id": "ba1796e6", + "id": "4dc0c8ff", "metadata": {}, "source": [ - "#### Hamiltonian → quantum circuit" + "**Step 1** — build the graph, cost Hamiltonian, and ansatz.\n" ] }, { "cell_type": "code", "execution_count": 19, - "id": "9693adfc", + "id": "94190344", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Output" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "circuit_100 = QAOAAnsatz(cost_operator=cost_hamiltonian_100, reps=1)\n", - "circuit_100.measure_all()\n", + "# Step 1: build the 100-node graph, cost Hamiltonian, and QAOA ansatz.\n", + "n_large = 100\n", + "graph_100 = rx.PyGraph()\n", + "graph_100.add_nodes_from(np.arange(0, n_large, 1))\n", + "elist = []\n", + "for edge in backend.coupling_map:\n", + " if edge[0] < n_large and edge[1] < n_large:\n", + " elist.append((edge[0], edge[1], 1.0))\n", + "graph_100.add_edges_from(elist)\n", "\n", - "circuit_100.draw(\"mpl\", fold=False, scale=0.2, idle_wires=False)" + "max_cut_paulis_100 = build_max_cut_paulis(graph_100)\n", + "cost_hamiltonian_100 = SparsePauliOp.from_sparse_list(max_cut_paulis_100, n_large)\n", + "\n", + "circuit_100 = QAOAAnsatz(cost_operator=cost_hamiltonian_100, reps=1)\n", + "circuit_100.measure_all()\n" ] }, { "cell_type": "markdown", - "id": "cf31d488-d672-4c91-8a80-867273502396", + "id": "c91f0c16", "metadata": {}, "source": [ - "### Step 2: Optimize problem for quantum execution\n", - "To scale the circuit optimization step to utility-scale problems, you can take advantage of the high performance transpilation strategies introduced in Qiskit SDK v1.0. Other tools include the new transpiler service with [AI enhanced transpiler passes](/docs/guides/ai-transpiler-passes)." + "**Step 2** — transpile for the selected hardware backend.\n" ] }, { "cell_type": "code", "execution_count": 20, - "id": "3a14e7ad", + "id": "2b59da0e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Output" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ + "# Step 2: transpile for hardware.\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", - "\n", - "candidate_circuit_100 = pm.run(circuit_100)\n", - "candidate_circuit_100.draw(\"mpl\", fold=False, scale=0.1, idle_wires=False)" - ] - }, - { - "cell_type": "markdown", - "id": "8a8e65f0-9089-4237-b833-6f99da859ce2", - "metadata": {}, - "source": [ - "### Step 3: Execute using Qiskit primitives\n", - "\n", - "To run QAOA, you must know the optimal parameters $\\gamma_k$ and $\\beta_k$ to put in the variational circuit. Optimize these parameters by running an optimization loop on the device. The cell submits jobs until the cost function value has converged and the optimal parameters for $\\gamma_k$ and $\\beta_k$ are determined." - ] - }, - { - "cell_type": "markdown", - "id": "5e11ce39-a046-4f65-a8e6-bc9ca123eb9a", - "metadata": {}, - "source": [ - "#### Find candidate solution by running the optimization on the device" + "candidate_circuit_100 = pm.run(circuit_100)\n" ] }, { "cell_type": "markdown", - "id": "7ac4b5df", + "id": "eb2c4d66", "metadata": {}, "source": [ - "First, run the optimization loop for the circuit parameters on a device." + "**Step 3** — run the QAOA optimization loop inside a session, then sample.\n" ] }, { "cell_type": "code", "execution_count": 21, - "id": "9521a963", + "id": "e5aceab3", "metadata": {}, "outputs": [ { @@ -1038,23 +934,23 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -3.9939191365979383\n", - " x: [ 1.571e+00 3.142e+00]\n", - " nfev: 29\n", + " fun: -17.172689238986344\n", + " x: [ 2.574e+00 4.166e+00]\n", + " nfev: 28\n", " maxcv: 0.0\n" ] } ], "source": [ + "# Step 3: run the QAOA optimization loop on the device, then sample the\n", + "# final distribution with the optimized parameters.\n", "initial_gamma = np.pi\n", "initial_beta = np.pi / 2\n", "init_params = [initial_beta, initial_gamma]\n", "\n", "objective_func_vals = [] # Global variable\n", "with Session(backend=backend) as session:\n", - " # If using qiskit-ibm-runtime<0.24.0, change `mode=` to `session=`\n", " estimator = Estimator(mode=session)\n", - "\n", " estimator.options.default_shots = 1000\n", "\n", " # Set simple error suppression/mitigation options\n", @@ -1062,6 +958,7 @@ " estimator.options.dynamical_decoupling.sequence_type = \"XY4\"\n", " estimator.options.twirling.enable_gates = True\n", " estimator.options.twirling.num_randomizations = \"auto\"\n", + " estimator.options.environment.job_tags = [\"TUT_QAOA\"]\n", "\n", " result = minimize(\n", " cost_func_estimator,\n", @@ -1069,55 +966,11 @@ " args=(candidate_circuit_100, cost_hamiltonian_100, estimator),\n", " method=\"COBYLA\",\n", " )\n", - " print(result)" - ] - }, - { - "cell_type": "markdown", - "id": "1ec8bdc0-48ed-42e2-a8f2-55d41432b383", - "metadata": {}, - "source": [ - "Once the optimal parameters from running QAOA on the device have been found, assign the parameters to the circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "1c432c2e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Output" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ + " print(result)\n", + "\n", + "# Assign optimal parameters and sample the final distribution.\n", "optimized_circuit_100 = candidate_circuit_100.assign_parameters(result.x)\n", - "optimized_circuit_100.draw(\"mpl\", fold=False, idle_wires=False)" - ] - }, - { - "cell_type": "markdown", - "id": "f3a9a3be-60db-41f0-9058-451c1f41a8a7", - "metadata": {}, - "source": [ - "Finally, execute the circuit with the optimal parameters to sample from the corresponding distribution." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "a5cc531b", - "metadata": {}, - "outputs": [], - "source": [ - "# If using qiskit-ibm-runtime<0.24.0, change `mode=` to `backend=`\n", + "\n", "sampler = Sampler(mode=backend)\n", "sampler.options.default_shots = 10000\n", "\n", @@ -1127,253 +980,93 @@ "sampler.options.twirling.enable_gates = True\n", "sampler.options.twirling.num_randomizations = \"auto\"\n", "\n", + "# Add a unique tag to the job execution\n", + "sampler.options.environment.job_tags = [\"TUT_QAOA\"]\n", "\n", "pub = (optimized_circuit_100,)\n", "job = sampler.run([pub], shots=int(1e4))\n", "\n", "counts_int = job.result()[0].data.meas.get_int_counts()\n", - "counts_bin = job.result()[0].data.meas.get_counts()\n", "shots = sum(counts_int.values())\n", "final_distribution_100_int = {\n", " key: val / shots for key, val in counts_int.items()\n", - "}" + "}\n" ] }, { "cell_type": "markdown", - "id": "7a8f4463", + "id": "7f0c5980", "metadata": {}, "source": [ - "Check that the cost minimized in the optimization loop has converged to a certain value." + "**Step 4** — post-process the sampled distribution to extract the best cut.\n" ] }, { "cell_type": "code", - "execution_count": 24, - "id": "0fda3611", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Output" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(12, 6))\n", - "plt.plot(objective_func_vals)\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Cost\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "c6b01763", - "metadata": {}, - "source": [ - "### Step 4: Post-process and return result in desired classical format" - ] - }, - { - "cell_type": "markdown", - "id": "da37beca", - "metadata": {}, - "source": [ - "Given that the likelihood of each solution is low, extract the solution that corresponds to the lowest cost." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "080e93a9", + "execution_count": 22, + "id": "010571f7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Result bitstring: [1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1]\n" + "Result bitstring: [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0]\n", + "The value of the cut is: 156\n" ] } ], "source": [ - "_PARITY = np.array(\n", - " [-1 if bin(i).count(\"1\") % 2 else 1 for i in range(256)],\n", - " dtype=np.complex128,\n", - ")\n", - "\n", - "\n", - "def evaluate_sparse_pauli(state: int, observable: SparsePauliOp) -> complex:\n", - " \"\"\"Utility for the evaluation of the expectation value of a measured state.\"\"\"\n", - " packed_uint8 = np.packbits(observable.paulis.z, axis=1, bitorder=\"little\")\n", - " state_bytes = np.frombuffer(\n", - " state.to_bytes(packed_uint8.shape[1], \"little\"), dtype=np.uint8\n", - " )\n", - " reduced = np.bitwise_xor.reduce(packed_uint8 & state_bytes, axis=1)\n", - " return np.sum(observable.coeffs * _PARITY[reduced])\n", - "\n", - "\n", - "def best_solution(samples, hamiltonian):\n", - " \"\"\"Find solution with lowest cost\"\"\"\n", - " min_cost = 1000\n", - " min_sol = None\n", - " for bit_str in samples.keys():\n", - " # Qiskit use little endian hence the [::-1]\n", - " candidate_sol = int(bit_str)\n", - " # fval = qp.objective.evaluate(candidate_sol)\n", - " fval = evaluate_sparse_pauli(candidate_sol, hamiltonian).real\n", - " if fval <= min_cost:\n", - " min_sol = candidate_sol\n", - "\n", - " return min_sol\n", - "\n", - "\n", + "# Step 4: find the best-cost sample and evaluate its cut value.\n", "best_sol_100 = best_solution(final_distribution_100_int, cost_hamiltonian_100)\n", "best_sol_bitstring_100 = to_bitstring(int(best_sol_100), len(graph_100))\n", "best_sol_bitstring_100.reverse()\n", "\n", - "print(\"Result bitstring:\", best_sol_bitstring_100)" + "print(\"Result bitstring:\", best_sol_bitstring_100)\n", + "\n", + "cut_value_100 = evaluate_sample(best_sol_bitstring_100, graph_100)\n", + "print(\"The value of the cut is:\", cut_value_100)\n" ] }, { "cell_type": "markdown", - "id": "7d0cac91", + "id": "large-scale-convergence-md", "metadata": {}, "source": [ - "Next, visualize the cut. Nodes of the same color belong to the same group." + "Check that the cost minimized in the optimization loop has converged, and visualize results.\n" ] }, { "cell_type": "code", - "execution_count": 26, - "id": "b4a25e28", + "execution_count": 23, + "id": "large-scale-viz", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "plot_result(graph_100, best_sol_bitstring_100)" - ] - }, - { - "cell_type": "markdown", - "id": "95507cce-16ec-433c-956b-c77f70d7a3ab", - "metadata": {}, - "source": [ - "Calculate the the value of the cut." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "dd015e77-c1b9-4d06-9163-3ef56cc810f7", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "The value of the cut is: 124\n" - ] - } - ], - "source": [ - "cut_value_100 = evaluate_sample(best_sol_bitstring_100, graph_100)\n", - "print(\"The value of the cut is:\", cut_value_100)" - ] - }, - { - "cell_type": "markdown", - "id": "be09c8ea", - "metadata": {}, - "source": [ - "Now you need to compute the objective value of each sample that you measured on the quantum computer. The sample with the lowest objective value is the solution returned by the quantum computer." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "27db70eb", - "metadata": {}, - "outputs": [], - "source": [ - "# auxiliary function to help plot cumulative distribution functions\n", - "def _plot_cdf(objective_values: dict, ax, color):\n", - " x_vals = sorted(objective_values.keys(), reverse=True)\n", - " y_vals = np.cumsum([objective_values[x] for x in x_vals])\n", - " ax.plot(x_vals, y_vals, color=color)\n", - "\n", - "\n", - "def plot_cdf(dist, ax, title):\n", - " _plot_cdf(\n", - " dist,\n", - " ax,\n", - " \"C1\",\n", - " )\n", - " ax.vlines(min(list(dist.keys())), 0, 1, \"C1\", linestyle=\"--\")\n", - "\n", - " ax.set_title(title)\n", - " ax.set_xlabel(\"Objective function value\")\n", - " ax.set_ylabel(\"Cumulative distribution function\")\n", - " ax.grid(alpha=0.3)\n", - "\n", - "\n", - "# auxiliary function to convert bit-strings to objective values\n", - "def samples_to_objective_values(samples, hamiltonian):\n", - " \"\"\"Convert the samples to values of the objective function.\"\"\"\n", - "\n", - " objective_values = defaultdict(float)\n", - " for bit_str, prob in samples.items():\n", - " candidate_sol = int(bit_str)\n", - " fval = evaluate_sparse_pauli(candidate_sol, hamiltonian).real\n", - " objective_values[fval] += prob\n", - "\n", - " return objective_values" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "33f0580d", - "metadata": {}, - "outputs": [], - "source": [ - "result_dist = samples_to_objective_values(\n", - " final_distribution_100_int, cost_hamiltonian_100\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "20b3480e", - "metadata": {}, - "source": [ - "Finally, you can plot the cumulative distribution function to visualize how each sample contributes to the total probability distribution and the corresponding objective value. The horizontal spread shows the range of objective values of the samples in the final distribution. Ideally, you would see that the cumulative distribution function has \"jumps\" at the lower end of the objective function value axis. This would mean that few solutions with low cost have high probability of being sampled. A smooth, wide curve indicates that each sample is similarly likely, and they can have very different objective values, low or high." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "4381a2b3", - "metadata": {}, - "outputs": [ + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -1381,8 +1074,22 @@ } ], "source": [ + "# Plot convergence\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(objective_func_vals)\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.show()\n", + "\n", + "# Visualize the cut\n", + "plot_result(graph_100, best_sol_bitstring_100)\n", + "\n", + "# Plot cumulative distribution function\n", + "result_dist = samples_to_objective_values(\n", + " final_distribution_100_int, cost_hamiltonian_100\n", + ")\n", "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", - "plot_cdf(result_dist, ax, \"Eagle device\")" + "plot_cdf(result_dist, ax, backend.name)\n" ] }, { @@ -1390,9 +1097,14 @@ "id": "69ebc85b-6a29-4671-8d16-1ac97f089607", "metadata": {}, "source": [ - "## Conclusion\n", - "\n", - "This tutorial demonstrated how to solve an optimization problem with a quantum computer using the Qiskit patterns framework. The demonstration included a utility-scale example, with circuit sizes that cannot be exactly simulated classically. Currently, quantum computers do not outperform classical computers for combinatorial optimization because of noise. However, the hardware is steadily improving, and new algorithms for quantum computers are continually being developed. Indeed, much of the research working on quantum heuristics for combinatorial optimization is tested with classical simulations that only allow for a small number of qubits, typically around 20 qubits. Now, with larger qubit counts and devices with less noise, researchers will be able to start benchmarking these quantum heuristics at large problem sizes on quantum hardware." + "## Next steps\n", + "If you found this work interesting, you might be interested in the following material:\n", + "\n", + "- [Advanced techniques for QAOA](/docs/en/tutorials/advanced-techniques-for-qaoa) — explores advanced strategies for improving QAOA performance\n", + "- [Multi-objective optimization challenge](https://github.com/qiskit-community/qdc-challenges-2025/blob/main/challenges/Track_B/qmoo/qmoo_qdc25.ipynb) — put your skills to the test with this community challenge on multi-objective quantum optimization\n", + "- [Transpilation documentation](/docs/guides/transpile) for fine-tuning circuit optimization\n", + "- [Error suppression and mitigation](/docs/guides/error-mitigation-and-suppression-techniques) for improving hardware results\n", + "\n" ] }, { @@ -1404,13 +1116,22 @@ "\n", "Please take this short survey to provide feedback on this tutorial. Your insights will help us improve our content offerings and user experience.\n", "\n", - "[Link to survey](https://your.feedback.ibm.com/jfe/form/SV_cNHi0H1YIagQZ9Q)" + "[Link to survey](https://your.feedback.ibm.com/jfe/form/SV_cNHi0H1YIagQZ9Q)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "a1b8767d", + "metadata": {}, + "source": [ + "© IBM Corp., 2017-2026" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1424,7 +1145,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3" + "version": "3.12.10" } }, "nbformat": 4, diff --git a/scripts/config/cspell/dictionaries/qiskit.txt b/scripts/config/cspell/dictionaries/qiskit.txt index 79dc454686e..3e9ab218b7a 100644 --- a/scripts/config/cspell/dictionaries/qiskit.txt +++ b/scripts/config/cspell/dictionaries/qiskit.txt @@ -428,6 +428,7 @@ cidx rbrack bitorder cvar +setminus qudits qutrits quasiprobabilities