From 948d70c418f057b848597d3515721bf56c3058d1 Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Wed, 22 Nov 2023 16:43:57 -0500 Subject: [PATCH 1/7] The transpilation tutorial has been updated to use the new runtime transpilation passes, and Batch --- docs/tutorials/user-transpiled-circuits.ipynb | 2694 +---------------- 1 file changed, 134 insertions(+), 2560 deletions(-) diff --git a/docs/tutorials/user-transpiled-circuits.ipynb b/docs/tutorials/user-transpiled-circuits.ipynb index 5e9350ebe..4a0c1bc74 100644 --- a/docs/tutorials/user-transpiled-circuits.ipynb +++ b/docs/tutorials/user-transpiled-circuits.ipynb @@ -4,1075 +4,119 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Submitting user-transpiled circuits using primitives\n", + "# Submit pre-transpiled circuits\n", + "\n", + "## Background\n", "\n", "To get the best performance from your circuits, the Qiskit Runtime service will pass all circuits through Qiskit's transpiler before running them. While this is usually a good thing, we might sometimes want to disable this by passing the argument `skip_transpilation=True` to the primitive we're using.\n", "\n", "For example, we may know better than the transpiler in some cases, or want to target a specific subset of qubits on a specific device. In this tutorial, we'll disable automatic transpilation to test the performance of different transpiler settings. This example will take you through the full process of creating, transpiling, and submitting circuits.\n", "\n", - "## Transpiling circuits for IBM Quantum devices\n", + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# Create circuit to test transpiler on\n", + "from qiskit import QuantumCircuit, transpile\n", + "from qiskit.circuit.library import GroverOperator, Diagonal\n", "\n", - "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later. " + "# Use Statevector object to calculate the ideal output\n", + "from qiskit.quantum_info import Statevector\n", + "from qiskit.visualization import plot_histogram\n", + "\n", + "# Qiskit Runtime\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Batch, Sampler\n", + "\n", + "# General imports\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2022-04-13T19:59:15.034547\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.5.1, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], "text/plain": [ - "
" + "'ibm_hanoi'" ] }, - "execution_count": 1, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Create circuit to test transpiler on\n", - "from qiskit import QuantumCircuit\n", - "from qiskit.circuit.library import GroverOperator, Diagonal\n", - "\n", - "oracle = Diagonal([1] * 7 + [-1])\n", - "qc = QuantumCircuit(3)\n", - "qc.h([0, 1, 2])\n", - "qc = qc.compose(GroverOperator(oracle))\n", - "\n", - "# Use Statevector object to calculate the ideal output\n", - "from qiskit.quantum_info import Statevector\n", - "\n", - "ideal_distribution = Statevector.from_instruction(qc).probabilities_dict()\n", + "# To run on hardware, select the backend with the fewest number of jobs in the queue\n", + "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n", + "backend = service.least_busy(operational=True, simulator=False)\n", + "backend.name" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "\n", - "from qiskit.visualization import plot_histogram\n", + "## Transpiling circuits for IBM Quantum devices\n", "\n", - "plot_histogram(ideal_distribution)" + "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later. " ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 48, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "Next, we need to choose a backend to transpile for. In the following cell, we create a service instance, which we'll use to start a session, and get the backend object, which contains information for the transpiler. Since the transpilation process depends on the device, we'll ask the runtime service for a specific device by name. In this example, we'll use `ibm_algiers`, which is only available through IBM Cloud." + "oracle = Diagonal([1] * 7 + [-1])\n", + "qc = QuantumCircuit(3)\n", + "qc.h([0, 1, 2])\n", + "qc = qc.compose(GroverOperator(oracle))\n", + "\n", + "qc.draw(output='mpl', style='iqp')" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "ideal_distribution = Statevector.from_instruction(qc).probabilities_dict()\n", "\n", - "service = QiskitRuntimeService()\n", - "backend = service.backend(\"ibm_algiers\")" + "plot_histogram(ideal_distribution)" ] }, { @@ -1086,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -1094,7 +138,7 @@ "output_type": "stream", "text": [ "CNOTs (optimization_level=0): 27\n", - "CNOTs (optimization_level=3): 12\n" + "CNOTs (optimization_level=3): 14\n" ] } ], @@ -1102,8 +146,6 @@ "# Need to add measurements to the circuit\n", "qc.measure_all()\n", "\n", - "from qiskit import transpile\n", - "\n", "circuits = []\n", "for optimization_level in [0, 3]:\n", " t_qc = transpile(qc, backend, optimization_level=optimization_level, seed_transpiler=0)\n", @@ -1117,55 +159,75 @@ "source": [ "Since CNOTs usually have a high error rate, the circuit transpiled with `optimization_level=3` should perform much better.\n", "\n", - "Another way we can improve performance is through [dynamic decoupling](https://qiskit.org/documentation/stubs/qiskit.transpiler.passes.DynamicalDecoupling.html), where we apply a sequence of gates to idling qubits. This cancels out some unwanted interactions with the environment. In the following cell, we add dynamic decoupling to the circuit transpiled with `optimization_level=3`, and add it to our list." + "Another way we can improve performance is through [dynamic decoupling](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-provider/qiskit_ibm_provider.transpiler.passes.scheduling.PadDynamicalDecoupling#paddynamicaldecoupling), where we apply a sequence of gates to idling qubits. This cancels out some unwanted interactions with the environment. In the following cell, we add dynamic decoupling to the circuit transpiled with `optimization_level=3`, and add it to our list." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ - "from qiskit.transpiler import PassManager, InstructionDurations\n", - "from qiskit.transpiler.passes import ASAPSchedule, DynamicalDecoupling\n", + "from qiskit.transpiler import PassManager\n", + "from qiskit_ibm_runtime.transpiler.passes.scheduling import (\n", + " ASAPScheduleAnalysis,\n", + " PadDynamicalDecoupling,\n", + ")\n", "from qiskit.circuit.library import XGate\n", "\n", "# Get gate durations so the transpiler knows how long each operation takes\n", - "durations = InstructionDurations.from_backend(backend)\n", + "durations = backend.target.durations()\n", "\n", "# This is the sequence we'll apply to idling qubits\n", "dd_sequence = [XGate(), XGate()]\n", "\n", "# Run scheduling and dynamic decoupling passes on circuit\n", - "pm = PassManager([ASAPSchedule(durations), DynamicalDecoupling(durations, dd_sequence)])\n", + "pm = PassManager([ASAPScheduleAnalysis(durations), PadDynamicalDecoupling(durations, dd_sequence)])\n", "circ_dd = pm.run(circuits[1])\n", "\n", "# Add this new circuit to our list\n", "circuits.append(circ_dd)" ] }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circ_dd.draw(output='mpl', style='iqp', idle_wires=False)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ + "## Run transpiled circuits using Qiskit Runtime\n", "\n", - "\n", - "## Run user-transpiled circuits using Qiskit Runtime\n", - "\n", - "At this point, we have a list of circuits (named `circuits`) transpiled for `ibm_algiers`. In the following cell, we create an instance of the sampler primitive, and start a session using the context manager (`with ...:`), which automatically opens and closes the session for us. This is where we pass the `skip_transpilation=True` argument.\n", + "At this point, we have a list of circuits transpiled for our system. In the following cell, we create an instance of the sampler primitive, and start a batched job using the context manager (`with ...:`), which automatically opens and closes the Batch for us. This is where we pass the `skip_transpilation=True` argument.\n", "\n", "Within the context manager, we sample the circuits and store the results to `result`." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ - "from qiskit_ibm_runtime import Sampler, Session\n", - "\n", - "with Session(service=service, backend=backend):\n", + "with Batch(service=service, backend=backend):\n", " sampler = Sampler()\n", " job = sampler.run(\n", " circuits=circuits, # sample all three circuits\n", @@ -1184,1495 +246,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2022-04-13T19:59:47.404379\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.5.1, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 6, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from qiskit.visualization import plot_histogram\n", - "\n", "binary_prob = [quasi_dist.binary_probabilities() for quasi_dist in result.quasi_dists]\n", "plot_histogram(\n", " binary_prob + [ideal_distribution],\n", @@ -2690,21 +279,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can confirm this by computing the [Hellinger fidelity](https://qiskit.org/documentation/stubs/qiskit.quantum_info.hellinger_fidelity.html) between each set of results and the ideal distribution (higher is better, and 1 is perfect fidelity)." + "We can confirm this by computing the [Hellinger fidelity](https://docs.quantum-computing.ibm.com/api/qiskit/quantum_info) between each set of results and the ideal distribution (higher is better, and 1 is perfect fidelity)." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.927\n", - "0.938\n", - "0.951\n" + "0.958\n", + "0.961\n", + "0.963\n" ] } ], @@ -2717,16 +306,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'0.4.0'" + "'0.15.0'" ] }, - "execution_count": 8, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } @@ -2739,47 +328,32 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.20.0
qiskit-aer0.9.1
qiskit-ignis0.7.0
qiskit-ibmq-provider0.18.3
qiskit-aqua0.9.5
qiskit0.34.0
qiskit-nature0.3.0
qiskit-finance0.2.1
qiskit-optimization0.2.3
qiskit-machine-learning0.2.1
System information
Python version3.9.10
Python compilerClang 13.0.0 (clang-1300.0.29.3)
Python buildmain, Jan 15 2022 11:48:00
OSDarwin
CPUs8
Memory (Gb)32.0
Wed Apr 13 19:59:49 2022 BST
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" - ], "text/plain": [ - "" + "'0.45.0'" ] }, + "execution_count": 30, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "from qiskit.tools.jupyter import *\n", + "import qiskit\n", "\n", - "%qiskit_version_table\n", - "%qiskit_copyright" + "qiskit.version.get_version_info()" ] } ], "metadata": { "kernelspec": { - "display_name": "primitives", + "display_name": "env", "language": "python", - "name": "primitives" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -2791,7 +365,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.6" } }, "nbformat": 4, From 64601835aea5be69ca255774021d71f814907e9e Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Wed, 22 Nov 2023 18:31:52 -0500 Subject: [PATCH 2/7] Fix style checker --- docs/tutorials/user-transpiled-circuits.ipynb | 25 ++++++++----------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/docs/tutorials/user-transpiled-circuits.ipynb b/docs/tutorials/user-transpiled-circuits.ipynb index 4a0c1bc74..163d41c9e 100644 --- a/docs/tutorials/user-transpiled-circuits.ipynb +++ b/docs/tutorials/user-transpiled-circuits.ipynb @@ -12,7 +12,7 @@ "\n", "For example, we may know better than the transpiler in some cases, or want to target a specific subset of qubits on a specific device. In this tutorial, we'll disable automatic transpilation to test the performance of different transpiler settings. This example will take you through the full process of creating, transpiling, and submitting circuits.\n", "\n", - "## Setup" + "## Setup\n" ] }, { @@ -30,11 +30,7 @@ "from qiskit.visualization import plot_histogram\n", "\n", "# Qiskit Runtime\n", - "from qiskit_ibm_runtime import QiskitRuntimeService, Batch, Sampler\n", - "\n", - "# General imports\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" + "from qiskit_ibm_runtime import QiskitRuntimeService, Batch, Sampler" ] }, { @@ -64,10 +60,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n", "## Transpiling circuits for IBM Quantum devices\n", "\n", - "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later. " + "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later.\n" ] }, { @@ -93,7 +88,7 @@ "qc.h([0, 1, 2])\n", "qc = qc.compose(GroverOperator(oracle))\n", "\n", - "qc.draw(output='mpl', style='iqp')" + "qc.draw(output=\"mpl\", style=\"iqp\")" ] }, { @@ -125,7 +120,7 @@ "source": [ "Next, we transpile the circuits for our backend. We're going to compare the performance of the transpiler with `optimization_level` set to `0` (lowest) against `3` (highest). The lowest optimization level just does the bare minimum needed to get the circuit running on the device; it maps the circuit qubits to the device qubits, and adds swaps gates to allow all 2-qubit operations. The highest optimization level is much smarter and uses lots of tricks to reduce the overall gate count. Since multi-qubit gates have high error rates, and qubits decohere over time, the shorter circuits should give better results.\n", "\n", - "In the following cell, we transpile `qc` for both values of `optimization_level`, print the number of CNOT gates, and add the transpiled circuits to a list. Some of the transpiler's algorithms are randomized, so we set a seed for reproducibility." + "In the following cell, we transpile `qc` for both values of `optimization_level`, print the number of CNOT gates, and add the transpiled circuits to a list. Some of the transpiler's algorithms are randomized, so we set a seed for reproducibility.\n" ] }, { @@ -159,7 +154,7 @@ "source": [ "Since CNOTs usually have a high error rate, the circuit transpiled with `optimization_level=3` should perform much better.\n", "\n", - "Another way we can improve performance is through [dynamic decoupling](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-provider/qiskit_ibm_provider.transpiler.passes.scheduling.PadDynamicalDecoupling#paddynamicaldecoupling), where we apply a sequence of gates to idling qubits. This cancels out some unwanted interactions with the environment. In the following cell, we add dynamic decoupling to the circuit transpiled with `optimization_level=3`, and add it to our list." + "Another way we can improve performance is through [dynamic decoupling](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-provider/qiskit_ibm_provider.transpiler.passes.scheduling.PadDynamicalDecoupling#paddynamicaldecoupling), where we apply a sequence of gates to idling qubits. This cancels out some unwanted interactions with the environment. In the following cell, we add dynamic decoupling to the circuit transpiled with `optimization_level=3`, and add it to our list.\n" ] }, { @@ -207,7 +202,7 @@ } ], "source": [ - "circ_dd.draw(output='mpl', style='iqp', idle_wires=False)" + "circ_dd.draw(output=\"mpl\", style=\"iqp\", idle_wires=False)" ] }, { @@ -218,7 +213,7 @@ "\n", "At this point, we have a list of circuits transpiled for our system. In the following cell, we create an instance of the sampler primitive, and start a batched job using the context manager (`with ...:`), which automatically opens and closes the Batch for us. This is where we pass the `skip_transpilation=True` argument.\n", "\n", - "Within the context manager, we sample the circuits and store the results to `result`." + "Within the context manager, we sample the circuits and store the results to `result`.\n" ] }, { @@ -241,7 +236,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, we can plot the results from the device runs against the ideal distribution. You can see the results with `optimization_level=3` are closer to the ideal distribution due to the lower gate count, and `optimization_level=3 + dd` is even closer due to the dynamic decoupling we applied." + "Finally, we can plot the results from the device runs against the ideal distribution. You can see the results with `optimization_level=3` are closer to the ideal distribution due to the lower gate count, and `optimization_level=3 + dd` is even closer due to the dynamic decoupling we applied.\n" ] }, { @@ -279,7 +274,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can confirm this by computing the [Hellinger fidelity](https://docs.quantum-computing.ibm.com/api/qiskit/quantum_info) between each set of results and the ideal distribution (higher is better, and 1 is perfect fidelity)." + "We can confirm this by computing the [Hellinger fidelity](https://docs.quantum-computing.ibm.com/api/qiskit/quantum_info) between each set of results and the ideal distribution (higher is better, and 1 is perfect fidelity).\n" ] }, { From f5e505b2c78a71bb47ba64b3a978fcab5ac355ac Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Tue, 28 Nov 2023 09:55:42 -0700 Subject: [PATCH 3/7] Updated names --- docs/tutorials/chsh_with_estimator.ipynb | 2 +- docs/tutorials/grover_with_sampler.ipynb | 2 +- docs/tutorials/qaoa_with_primitives.ipynb | 6 +++--- docs/tutorials/vqe_with_estimator.ipynb | 8 ++++---- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/tutorials/chsh_with_estimator.ipynb b/docs/tutorials/chsh_with_estimator.ipynb index c1c5f05aa..69b03e9b6 100644 --- a/docs/tutorials/chsh_with_estimator.ipynb +++ b/docs/tutorials/chsh_with_estimator.ipynb @@ -322,7 +322,7 @@ "id": "ace7dc90", "metadata": {}, "source": [ - "## Analyze the results\n", + "## Step 4: Post-process, return result in classical format.\n", "\n", "After running the circuits, we need to build the CHSH witness functions. We first build the quantities $\\langle AB \\rangle$, $\\langle Ab \\rangle$, $\\langle aB \\rangle$, and $\\langle ab \\rangle$, by looking at the parity of the outcomes for the four families of circuits we built (two measurement bases for each of the two qubits). Then we use those quantities to build the witness functions as defined previously." ] diff --git a/docs/tutorials/grover_with_sampler.ipynb b/docs/tutorials/grover_with_sampler.ipynb index 3a98086ae..f5d5fa865 100644 --- a/docs/tutorials/grover_with_sampler.ipynb +++ b/docs/tutorials/grover_with_sampler.ipynb @@ -295,7 +295,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Analyze the results" + "## Step 4: Post-process, return result in classical format." ] }, { diff --git a/docs/tutorials/qaoa_with_primitives.ipynb b/docs/tutorials/qaoa_with_primitives.ipynb index 38ea936fa..23e1b18f2 100644 --- a/docs/tutorials/qaoa_with_primitives.ipynb +++ b/docs/tutorials/qaoa_with_primitives.ipynb @@ -74,7 +74,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Map the problem to a quantum-native format\n", + "## Step 1: Generate quantum circuits and operators.\n", "\n", "To demonstrate max-cut, we'll create a graph using the [rustworkx library](https://github.com/Qiskit/rustworkx), and create Pauli Hamiltonian that encodes the cost in a manner such that the minimum expectation value of the operator corresponds to the maximum number of edges between the nodes in two different groups." ] @@ -179,7 +179,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimize the circuits and operators\n", + "## Step 2: Optimize problem for quantum execution.\n", "\n", "We can schedule a series of [qiskit.transpiler](https://docs.quantum-computing.ibm.com/api/qiskit/transpiler) passes to optimize our circuit for a selected backend. This includes a few components:\n", "\n", @@ -273,7 +273,7 @@ "id": "b58c33dc", "metadata": {}, "source": [ - "## Execute using a quantum primitive function" + "## Step 3: Execute using Qiskit Primitives." ] }, { diff --git a/docs/tutorials/vqe_with_estimator.ipynb b/docs/tutorials/vqe_with_estimator.ipynb index 6dc49c243..1aa5a960e 100644 --- a/docs/tutorials/vqe_with_estimator.ipynb +++ b/docs/tutorials/vqe_with_estimator.ipynb @@ -94,7 +94,7 @@ "id": "988ee237", "metadata": {}, "source": [ - "## Map the problem to a quantum-native format\n", + "## Step 1: Generate quantum circuits and operators.\n", "\n", "Here we define the problem instance for our VQE algorithm. Although the problem in question can come from a variety of domains, the form for execution through Qiskit Runtime is the same. Qiskit provides a convenience class for expressing Hamiltonians in Pauli form, and a collection of widely used ansatz circuits in the [`qiskit.circuit.library`](https://docs.quantum-computing.ibm.com/api/qiskit/circuit_library).\n", "\n", @@ -180,7 +180,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimize the circuits and operators\n", + "## Step 2: Optimize problem for quantum execution.\n", "\n", "We can schedule a series of [`qiskit.transpiler`](https://docs.quantum-computing.ibm.com/api/qiskit/transpiler) passes to optimize our circuit for a selected backend. This includes a few components:\n", "\n", @@ -274,7 +274,7 @@ "id": "b4d480b3", "metadata": {}, "source": [ - "## Execute using a quantum primitive function\n", + "## Step 3: Execute using Qiskit Primitives.\n", "\n", "Like many classical optimization problems, the solution to a VQE problem can be formulated as minimization of a scalar cost function. By definition, VQE looks to find the ground state solution to a Hamiltonian by optimizing the ansatz circuit parameters to minimize the expectation value (energy) of the Hamiltonian. With the Qiskit Runtime [`Estimator`](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-runtime/qiskit_ibm_runtime.Estimator) directly taking a Hamiltonian and parameterized ansatz, and returning the necessary energy, the cost function for a VQE instance is quite simple:" ] @@ -486,7 +486,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Analyze the results" + "## Step 4: Post-process, return result in classical format." ] }, { From f81c30fad36492b31eb74e1624a7778eb3b22b53 Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Tue, 28 Nov 2023 09:59:22 -0700 Subject: [PATCH 4/7] Updated section names for transpiled tutorial --- docs/tutorials/user-transpiled-circuits.ipynb | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/user-transpiled-circuits.ipynb b/docs/tutorials/user-transpiled-circuits.ipynb index 163d41c9e..297a8da3b 100644 --- a/docs/tutorials/user-transpiled-circuits.ipynb +++ b/docs/tutorials/user-transpiled-circuits.ipynb @@ -60,7 +60,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Transpiling circuits for IBM Quantum devices\n", + "## Step 1: Generate quantum circuits and operators.\n", "\n", "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later.\n" ] @@ -118,6 +118,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Step 2: Optimize problem for quantum execution.\n", + "\n", "Next, we transpile the circuits for our backend. We're going to compare the performance of the transpiler with `optimization_level` set to `0` (lowest) against `3` (highest). The lowest optimization level just does the bare minimum needed to get the circuit running on the device; it maps the circuit qubits to the device qubits, and adds swaps gates to allow all 2-qubit operations. The highest optimization level is much smarter and uses lots of tricks to reduce the overall gate count. Since multi-qubit gates have high error rates, and qubits decohere over time, the shorter circuits should give better results.\n", "\n", "In the following cell, we transpile `qc` for both values of `optimization_level`, print the number of CNOT gates, and add the transpiled circuits to a list. Some of the transpiler's algorithms are randomized, so we set a seed for reproducibility.\n" @@ -209,7 +211,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Run transpiled circuits using Qiskit Runtime\n", + "## Step 3: Execute using Qiskit Primitives.\n", "\n", "At this point, we have a list of circuits transpiled for our system. In the following cell, we create an instance of the sampler primitive, and start a batched job using the context manager (`with ...:`), which automatically opens and closes the Batch for us. This is where we pass the `skip_transpilation=True` argument.\n", "\n", @@ -236,6 +238,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Step 4: Post-process, return result in classical format.\n", + "\n", "Finally, we can plot the results from the device runs against the ideal distribution. You can see the results with `optimization_level=3` are closer to the ideal distribution due to the lower gate count, and `optimization_level=3 + dd` is even closer due to the dynamic decoupling we applied.\n" ] }, From a67f469d242e07eaf6519a68a8b89f35c79d29e8 Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Tue, 28 Nov 2023 10:01:09 -0700 Subject: [PATCH 5/7] Updated grover --- docs/tutorials/grover_with_sampler.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/grover_with_sampler.ipynb b/docs/tutorials/grover_with_sampler.ipynb index f5d5fa865..4b03c1866 100644 --- a/docs/tutorials/grover_with_sampler.ipynb +++ b/docs/tutorials/grover_with_sampler.ipynb @@ -82,7 +82,7 @@ "id": "d4845f4d", "metadata": {}, "source": [ - "## Map the problem to a quantum-native format\n", + "## Step 1: Generate quantum circuits and operators.\n", "\n", "Grover's algorithm requires an [oracle](https://learning.quantum-computing.ibm.com/course/fundamentals-of-quantum-algorithms/grovers-algorithm) that specifies one or more marked computational basis states, where \"marked\" means a state with a phase of -1. A controlled-Z gate, or its multi-controlled generalization over $N$ qubits, marks the $2^{N}-1$ state (`'1'`*$N$ bit-string). Marking basis states with one or more `'0'` in the binary representation requires applying X-gates on the corresponding qubits before and after the controlled-Z gate; equivalent to having an open-control on that qubit. In the following code, we define an oracle that does just that, marking one or more input basis states defined through their bit-string representation. The `MCMT` gate is used to implement the multi-controlled Z-gate." ] @@ -260,7 +260,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimize the circuits and operators\n", + "## Step 2: Optimize problem for quantum execution.\n", "\n", "For this example, the circuit the operators are simple, so no optimizations are needed." ] @@ -271,7 +271,7 @@ "id": "c5edec73", "metadata": {}, "source": [ - "## Execute using a quantum primitive function\n", + "## Step 3: Execute using Qiskit Primitives.\n", "\n", "Amplitude amplification is a sampling problem that is suitable for execution with the [`Sampler`](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-runtime/qiskit_ibm_runtime.Sampler#sampler) runtime primitive. Because we have a single circuit, we instantiate the [`Batch`](https://docs.quantum-computing.ibm.com/run/run-primitives-batch) context manager to run our non-iterative workload." ] From d98a0d5107e0ee04a7a3a743ad773df9790fc11c Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Tue, 28 Nov 2023 10:05:20 -0700 Subject: [PATCH 6/7] Fixed consistency --- docs/tutorials/chsh_with_estimator.ipynb | 13 +++---------- docs/tutorials/qaoa_with_primitives.ipynb | 2 +- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/docs/tutorials/chsh_with_estimator.ipynb b/docs/tutorials/chsh_with_estimator.ipynb index 69b03e9b6..317b2bd19 100644 --- a/docs/tutorials/chsh_with_estimator.ipynb +++ b/docs/tutorials/chsh_with_estimator.ipynb @@ -146,7 +146,7 @@ "id": "66d5e2e2", "metadata": {}, "source": [ - "## Map the problem to a quantum-native format" + "## Step 1: Generate quantum circuits and operators." ] }, { @@ -240,7 +240,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimize the circuits and operators\n", + "## Step 2: Optimize problem for quantum execution.\n", "\n", "For this example, the circuit and the operators are simple, so no optimizations are needed." ] @@ -250,7 +250,7 @@ "id": "b7194399", "metadata": {}, "source": [ - "## Execute using a quantum primitive function\n", + "## Step 3: Execute using Qiskit Primitives.\n", "\n", "In order to execute the entire experiment in one call to the [`Estimator`](https://docs.quantum-computing.ibm.com/api/qiskit-ibm-runtime/qiskit_ibm_runtime.Estimator#estimator) we need to batch the circuit and operators together, repeating each for the requested `number_of_phases` points." ] @@ -447,13 +447,6 @@ "\n", "qiskit.version.get_version_info()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/docs/tutorials/qaoa_with_primitives.ipynb b/docs/tutorials/qaoa_with_primitives.ipynb index 23e1b18f2..d89393eb9 100644 --- a/docs/tutorials/qaoa_with_primitives.ipynb +++ b/docs/tutorials/qaoa_with_primitives.ipynb @@ -420,7 +420,7 @@ "id": "d162e690", "metadata": {}, "source": [ - "## Analyze the results" + "## Step 4: Post-process, return result in classical format." ] }, { From 7488f8fb78e084961aa4219caeab0abe27ced624 Mon Sep 17 00:00:00 2001 From: Sanket Panda Date: Tue, 28 Nov 2023 19:09:11 -0700 Subject: [PATCH 7/7] Final updates --- docs/tutorials/chsh_with_estimator.ipynb | 2 +- docs/tutorials/grover_with_sampler.ipynb | 2 +- docs/tutorials/qaoa_with_primitives.ipynb | 2 +- docs/tutorials/user-transpiled-circuits.ipynb | 2 +- docs/tutorials/vqe_with_estimator.ipynb | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/tutorials/chsh_with_estimator.ipynb b/docs/tutorials/chsh_with_estimator.ipynb index 317b2bd19..fe4e2e380 100644 --- a/docs/tutorials/chsh_with_estimator.ipynb +++ b/docs/tutorials/chsh_with_estimator.ipynb @@ -146,7 +146,7 @@ "id": "66d5e2e2", "metadata": {}, "source": [ - "## Step 1: Generate quantum circuits and operators." + "## Step 1: Map classical inputs to a quantum problem" ] }, { diff --git a/docs/tutorials/grover_with_sampler.ipynb b/docs/tutorials/grover_with_sampler.ipynb index 4b03c1866..a1cbd2787 100644 --- a/docs/tutorials/grover_with_sampler.ipynb +++ b/docs/tutorials/grover_with_sampler.ipynb @@ -82,7 +82,7 @@ "id": "d4845f4d", "metadata": {}, "source": [ - "## Step 1: Generate quantum circuits and operators.\n", + "## Step 1: Map classical inputs to a quantum problem\n", "\n", "Grover's algorithm requires an [oracle](https://learning.quantum-computing.ibm.com/course/fundamentals-of-quantum-algorithms/grovers-algorithm) that specifies one or more marked computational basis states, where \"marked\" means a state with a phase of -1. A controlled-Z gate, or its multi-controlled generalization over $N$ qubits, marks the $2^{N}-1$ state (`'1'`*$N$ bit-string). Marking basis states with one or more `'0'` in the binary representation requires applying X-gates on the corresponding qubits before and after the controlled-Z gate; equivalent to having an open-control on that qubit. In the following code, we define an oracle that does just that, marking one or more input basis states defined through their bit-string representation. The `MCMT` gate is used to implement the multi-controlled Z-gate." ] diff --git a/docs/tutorials/qaoa_with_primitives.ipynb b/docs/tutorials/qaoa_with_primitives.ipynb index d89393eb9..835495c25 100644 --- a/docs/tutorials/qaoa_with_primitives.ipynb +++ b/docs/tutorials/qaoa_with_primitives.ipynb @@ -74,7 +74,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 1: Generate quantum circuits and operators.\n", + "## Step 1: Map classical inputs to a quantum problem\n", "\n", "To demonstrate max-cut, we'll create a graph using the [rustworkx library](https://github.com/Qiskit/rustworkx), and create Pauli Hamiltonian that encodes the cost in a manner such that the minimum expectation value of the operator corresponds to the maximum number of edges between the nodes in two different groups." ] diff --git a/docs/tutorials/user-transpiled-circuits.ipynb b/docs/tutorials/user-transpiled-circuits.ipynb index 297a8da3b..fe78ab888 100644 --- a/docs/tutorials/user-transpiled-circuits.ipynb +++ b/docs/tutorials/user-transpiled-circuits.ipynb @@ -60,7 +60,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 1: Generate quantum circuits and operators.\n", + "## Step 1: Map classical inputs to a quantum problem\n", "\n", "In the following code cell, we create a small circuit that our transpiler will try to optimize. In this example, we create a circuit that carries out Grover's algorithm, with an oracle that marks the state `111`. We then simulate the ideal distribution (what we'd expect to measure if we ran this on a perfect quantum computer, an infinite number of times) for comparison later.\n" ] diff --git a/docs/tutorials/vqe_with_estimator.ipynb b/docs/tutorials/vqe_with_estimator.ipynb index 1aa5a960e..57987e522 100644 --- a/docs/tutorials/vqe_with_estimator.ipynb +++ b/docs/tutorials/vqe_with_estimator.ipynb @@ -94,7 +94,7 @@ "id": "988ee237", "metadata": {}, "source": [ - "## Step 1: Generate quantum circuits and operators.\n", + "## Step 1: Map classical inputs to a quantum problem\n", "\n", "Here we define the problem instance for our VQE algorithm. Although the problem in question can come from a variety of domains, the form for execution through Qiskit Runtime is the same. Qiskit provides a convenience class for expressing Hamiltonians in Pauli form, and a collection of widely used ansatz circuits in the [`qiskit.circuit.library`](https://docs.quantum-computing.ibm.com/api/qiskit/circuit_library).\n", "\n",