From dc8e8e16dc8c38b908a866736bcd407d72e10915 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Thu, 26 Oct 2023 11:23:49 -0400 Subject: [PATCH 01/48] Added intro page --- docs/transpile/_toc.json | 14 +++++ docs/transpile/index.mdx | 14 +++++ docs/transpile/transpiler-introduction.ipynb | 62 ++++++++++++++++++++ 3 files changed, 90 insertions(+) create mode 100644 docs/transpile/_toc.json create mode 100644 docs/transpile/index.mdx create mode 100644 docs/transpile/transpiler-introduction.ipynb diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json new file mode 100644 index 00000000000..1421a513d63 --- /dev/null +++ b/docs/transpile/_toc.json @@ -0,0 +1,14 @@ +{ + "title": "Transpile", + "children": [ + { + "title": "Introduction", + "url": "/transpile" + }, + { + "title": "Introduction to the Transpiler", + "url": "/transpile/transpiler-introduction" + } + ] + } + \ No newline at end of file diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx new file mode 100644 index 00000000000..e4f21349e5f --- /dev/null +++ b/docs/transpile/index.mdx @@ -0,0 +1,14 @@ +--- +title: Introduction +description: Introduction to the transpiler + +--- + + +# Introduction to the Transpiler + +A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. + +In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device. + +***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.). \ No newline at end of file diff --git a/docs/transpile/transpiler-introduction.ipynb b/docs/transpile/transpiler-introduction.ipynb new file mode 100644 index 00000000000..7b0f4b2ed0e --- /dev/null +++ b/docs/transpile/transpiler-introduction.ipynb @@ -0,0 +1,62 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to the Transpiler\n", + "\n", + "A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits.\n", + "\n", + "In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device.\n", + "\n", + "***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Abstraction Levels of Circuits\n", + "\n", + "- \"Virtual\" qubits\n", + "- Physical qubits selected\n", + "- Scheduled circuits\n", + "\n", + "\n", + "## What levels are needed?\n", + " - For the sampler/estimator?\n", + " - For backend.run?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "description": "Transpiler introduction notebook", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + }, + "title": "Transpiler Introduction" + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 6a4ebf4e7b65c2b661979c726808eb87c006c13c Mon Sep 17 00:00:00 2001 From: kaelynj Date: Thu, 26 Oct 2023 15:04:25 -0400 Subject: [PATCH 02/48] Added content draft --- docs/transpile/index.mdx | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index e4f21349e5f..c29eb4d19f0 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -7,8 +7,18 @@ description: Introduction to the transpiler # Introduction to the Transpiler -A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. +Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present day noisy quantum systems. A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. -In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device. -***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.). \ No newline at end of file +This documentation covers the tooling and workflows available to Qiskit users. If you're using Primitives and interested in just using the default transpilation options, look to the section "Configuring Runtime Error Suppression" (*add link to file*). + + +## Transformation Passes +For more advanced users, it is important to understand the various representations of quantum circuits that are used for the transpilation step along with the transformations (i.e. *passes*) that affect the efficiency of the final circuit that is sent to the backend. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: + +1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all 1 and 2 qubit gates. +1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. +1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e. SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. +1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. +1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). +1. `scheduling` - This pass is for any hardware-aware optimizations which improve the efficiency of the executed microwave pulse instructions. \ No newline at end of file From c7da51fa5e6f70c8e469dc3dc77e3234c0226b80 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 27 Oct 2023 11:03:05 -0400 Subject: [PATCH 03/48] ajc tweaks --- docs/transpile/index.mdx | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index c29eb4d19f0..9dd87359c20 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -1,24 +1,25 @@ --- -title: Introduction +title: Introduction to the transpiler description: Introduction to the transpiler --- -# Introduction to the Transpiler +# Introduction to the transpiler -Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present day noisy quantum systems. A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. +Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. +A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. -This documentation covers the tooling and workflows available to Qiskit users. If you're using Primitives and interested in just using the default transpilation options, look to the section "Configuring Runtime Error Suppression" (*add link to file*). +This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in st using the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-error-suppression) -## Transformation Passes -For more advanced users, it is important to understand the various representations of quantum circuits that are used for the transpilation step along with the transformations (i.e. *passes*) that affect the efficiency of the final circuit that is sent to the backend. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: +## Transformation passes +For more advanced users, it is important to understand the various representations of quantum circuits that are used for the transpilation step along with the transformations (i.e., *passes*) that affect the efficiency of the final circuit that is sent to the backend. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: -1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all 1 and 2 qubit gates. +1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. -1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e. SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. +1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. 1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. 1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). -1. `scheduling` - This pass is for any hardware-aware optimizations which improve the efficiency of the executed microwave pulse instructions. \ No newline at end of file +1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. \ No newline at end of file From 11b0391d73242ebcb082fc7a82bd4d1855351e98 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Tue, 31 Oct 2023 12:08:24 -0400 Subject: [PATCH 04/48] remove duplicate file --- .../__transpiler_passes_and_passmanager.ipynb | 6904 ----------------- docs/transpile/_toc.json | 4 - 2 files changed, 6908 deletions(-) delete mode 100644 docs/transpile/__transpiler_passes_and_passmanager.ipynb diff --git a/docs/transpile/__transpiler_passes_and_passmanager.ipynb b/docs/transpile/__transpiler_passes_and_passmanager.ipynb deleted file mode 100644 index 55eedf7a768..00000000000 --- a/docs/transpile/__transpiler_passes_and_passmanager.ipynb +++ /dev/null @@ -1,6904 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Transpiler Passes and Pass Manager" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introduction" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits.\n", - "\n", - "In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device.\n", - "\n", - "***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:56.857930Z", - "start_time": "2019-12-10T21:47:54.444353Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:30.918072Z", - "iopub.status.busy": "2023-08-25T18:25:30.917826Z", - "iopub.status.idle": "2023-08-25T18:25:31.520463Z", - "shell.execute_reply": "2023-08-25T18:25:31.519613Z" - } - }, - "outputs": [], - "source": [ - "from qiskit import QuantumCircuit\n", - "from qiskit.compiler import transpile\n", - "from qiskit.transpiler import PassManager" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2019-08-21T09:12:12.822442Z", - "start_time": "2019-08-21T09:12:12.819902Z" - } - }, - "source": [ - "## PassManager object\n", - "\n", - "Lets you specify the set of passes you want." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:57.268332Z", - "start_time": "2019-12-10T21:47:56.860709Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:31.526622Z", - "iopub.status.busy": "2023-08-25T18:25:31.525089Z", - "iopub.status.idle": "2023-08-25T18:25:32.402259Z", - "shell.execute_reply": "2023-08-25T18:25:32.401532Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "circ = QuantumCircuit(3)\n", - "circ.ccx(0, 1, 2)\n", - "circ.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:57.533035Z", - "start_time": "2019-12-10T21:47:57.270693Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:32.407275Z", - "iopub.status.busy": "2023-08-25T18:25:32.405984Z", - "iopub.status.idle": "2023-08-25T18:25:32.807173Z", - "shell.execute_reply": "2023-08-25T18:25:32.806412Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.transpiler.passes import Unroller\n", - "pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])\n", - "pm = PassManager(pass_)\n", - "new_circ = pm.run(circ)\n", - "new_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "All of Qiskit's transpiler passes are accessible from ``qiskit.transpiler.passes``." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:57.539422Z", - "start_time": "2019-12-10T21:47:57.535048Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:32.812347Z", - "iopub.status.busy": "2023-08-25T18:25:32.811101Z", - "iopub.status.idle": "2023-08-25T18:25:32.827192Z", - "shell.execute_reply": "2023-08-25T18:25:32.826554Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "['ALAPSchedule',\n", - " 'ALAPScheduleAnalysis',\n", - " 'ASAPSchedule',\n", - " 'ASAPScheduleAnalysis',\n", - " 'AlignMeasures',\n", - " 'ApplyLayout',\n", - " 'BIPMapping',\n", - " 'BarrierBeforeFinalMeasurements',\n", - " 'BasicSwap',\n", - " 'BasisTranslator',\n", - " 'CSPLayout',\n", - " 'CXCancellation',\n", - " 'CXDirection',\n", - " 'CheckCXDirection',\n", - " 'CheckGateDirection',\n", - " 'CheckMap',\n", - " 'Collect1qRuns',\n", - " 'Collect2qBlocks',\n", - " 'CollectCliffords',\n", - " 'CollectLinearFunctions',\n", - " 'CollectMultiQBlocks',\n", - " 'CommutationAnalysis',\n", - " 'CommutativeCancellation',\n", - " 'CommutativeInverseCancellation',\n", - " 'Commuting2qGateRouter',\n", - " 'ConsolidateBlocks',\n", - " 'ConstrainedReschedule',\n", - " 'ContainsInstruction',\n", - " 'ConvertConditionsToIfOps',\n", - " 'CountOps',\n", - " 'CountOpsLongestPath',\n", - " 'CrosstalkAdaptiveSchedule',\n", - " 'DAGFixedPoint',\n", - " 'DAGLongestPath',\n", - " 'Decompose',\n", - " 'DenseLayout',\n", - " 'Depth',\n", - " 'DynamicalDecoupling',\n", - " 'EchoRZXWeylDecomposition',\n", - " 'EnlargeWithAncilla',\n", - " 'Error',\n", - " 'FixedPoint',\n", - " 'FullAncillaAllocation',\n", - " 'GateDirection',\n", - " 'GatesInBasis',\n", - " 'HighLevelSynthesis',\n", - " 'HoareOptimizer',\n", - " 'InstructionDurationCheck',\n", - " 'InverseCancellation',\n", - " 'Layout2qDistance',\n", - " 'LayoutTransformation',\n", - " 'LinearFunctionsSynthesis',\n", - " 'LinearFunctionsToPermutations',\n", - " 'LookaheadSwap',\n", - " 'MergeAdjacentBarriers',\n", - " 'MinimumPoint',\n", - " 'NoiseAdaptiveLayout',\n", - " 'NumTensorFactors',\n", - " 'Optimize1qGates',\n", - " 'Optimize1qGatesDecomposition',\n", - " 'Optimize1qGatesSimpleCommutation',\n", - " 'OptimizeCliffords',\n", - " 'OptimizeSwapBeforeMeasure',\n", - " 'PadDelay',\n", - " 'PadDynamicalDecoupling',\n", - " 'PulseGates',\n", - " 'RZXCalibrationBuilder',\n", - " 'RZXCalibrationBuilderNoEcho',\n", - " 'RemoveBarriers',\n", - " 'RemoveDiagonalGatesBeforeMeasure',\n", - " 'RemoveFinalMeasurements',\n", - " 'RemoveResetInZeroState',\n", - " 'ResetAfterMeasureSimplification',\n", - " 'ResourceEstimation',\n", - " 'SabreLayout',\n", - " 'SabreSwap',\n", - " 'SetIOLatency',\n", - " 'SetLayout',\n", - " 'Size',\n", - " 'SolovayKitaev',\n", - " 'SolovayKitaevSynthesis',\n", - " 'StochasticSwap',\n", - " 'TemplateOptimization',\n", - " 'TimeUnitConversion',\n", - " 'TranslateParameterizedGates',\n", - " 'TrivialLayout',\n", - " 'UnitarySynthesis',\n", - " 'Unroll3qOrMore',\n", - " 'UnrollCustomDefinitions',\n", - " 'UnrollForLoops',\n", - " 'Unroller',\n", - " 'VF2Layout',\n", - " 'VF2PostLayout',\n", - " 'ValidatePulseGates',\n", - " 'Width']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.transpiler import passes\n", - "[pass_ for pass_ in dir(passes) if pass_[0].isupper()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Different Variants of the Same Pass\n", - "\n", - "There can be passes that do the same job, but in different ways. For example, the ``TrivialLayout``, ``DenseLayout`` and ``NoiseAdaptiveLayout`` all choose a layout (binding of virtual qubits to physical qubits), but use different algorithms and objectives. Similarly, the ``BasicSwap``, ``LookaheadSwap`` and ``StochasticSwap`` all insert swaps to make the circuit compatible with the coupling map. The modularity of the transpiler allows plug-and-play replacements for each pass.\n", - "\n", - "Below, we show the swapper passes all applied to the same circuit, to transform it to match a linear chain topology. You can see differences in performance, where the ``StochasticSwap`` is clearly the best. However, this can vary depending on the input circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:57.681468Z", - "start_time": "2019-12-10T21:47:57.541513Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:32.831761Z", - "iopub.status.busy": "2023-08-25T18:25:32.830596Z", - "iopub.status.idle": "2023-08-25T18:25:32.951486Z", - "shell.execute_reply": "2023-08-25T18:25:32.950648Z" - } - }, - "outputs": [], - "source": [ - "from qiskit.transpiler import CouplingMap, Layout\n", - "from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap\n", - "\n", - "coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]\n", - "\n", - "circuit = QuantumCircuit(7)\n", - "circuit.h(3)\n", - "circuit.cx(0, 6)\n", - "circuit.cx(6, 0)\n", - "circuit.cx(0, 1)\n", - "circuit.cx(3, 1)\n", - "circuit.cx(3, 0)\n", - "\n", - "coupling_map = CouplingMap(couplinglist=coupling)\n", - "\n", - "bs = BasicSwap(coupling_map=coupling_map)\n", - "pass_manager = PassManager(bs)\n", - "basic_circ = pass_manager.run(circuit)\n", - "\n", - "ls = LookaheadSwap(coupling_map=coupling_map)\n", - "pass_manager = PassManager(ls)\n", - "lookahead_circ = pass_manager.run(circuit)\n", - "\n", - "ss = StochasticSwap(coupling_map=coupling_map)\n", - "pass_manager = PassManager(ss)\n", - "stochastic_circ = pass_manager.run(circuit)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:57.902461Z", - "start_time": "2019-12-10T21:47:57.682997Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:32.956196Z", - "iopub.status.busy": "2023-08-25T18:25:32.955645Z", - "iopub.status.idle": "2023-08-25T18:25:33.283035Z", - "shell.execute_reply": "2023-08-25T18:25:33.282166Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "circuit.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:58.238179Z", - "start_time": "2019-12-10T21:47:57.904473Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:33.286999Z", - "iopub.status.busy": "2023-08-25T18:25:33.286654Z", - "iopub.status.idle": "2023-08-25T18:25:33.723644Z", - "shell.execute_reply": "2023-08-25T18:25:33.722762Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "basic_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:58.643611Z", - "start_time": "2019-12-10T21:47:58.241545Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:33.727109Z", - "iopub.status.busy": "2023-08-25T18:25:33.726836Z", - "iopub.status.idle": "2023-08-25T18:25:34.157478Z", - "shell.execute_reply": "2023-08-25T18:25:34.155557Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lookahead_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:58.935337Z", - "start_time": "2019-12-10T21:47:58.646318Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:34.162468Z", - "iopub.status.busy": "2023-08-25T18:25:34.161164Z", - "iopub.status.idle": "2023-08-25T18:25:34.537478Z", - "shell.execute_reply": "2023-08-25T18:25:34.536630Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stochastic_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Preset Pass Managers\n", - "\n", - "Qiskit comes with several pre-defined pass managers, corresponding to various levels of optimization achieved through different pipelines of passes. Currently ``optimization_level`` 0 through 3 are supported; the higher the number, the more optimized it is, at the expense of more time. Choosing a good pass manager may take trial and error, as it depends heavily on the circuit being transpiled and the backend being targeted.\n", - "\n", - "Here we illustrate the different levels by looking at a state synthesis circuit. We initialize four qubits to an arbitrary state, and then try to optimize the circuit that achieves this.\n", - "\n", - "- ``optimization_level=0``: just maps the circuit to the backend, with no explicit optimization (except whatever optimizations the mapper does).\n", - "\n", - "- ``optimization_level=1``: maps the circuit, but also does light-weight optimizations by collapsing adjacent gates.\n", - "\n", - "- ``optimization_level=2``: medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships.\n", - "\n", - "- ``optimization_level=3``: heavy-weight optimization, which in addition to previous steps, does resynthesis of two-qubit blocks of gates in the circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:58.956270Z", - "start_time": "2019-12-10T21:47:58.937115Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:34.541000Z", - "iopub.status.busy": "2023-08-25T18:25:34.540619Z", - "iopub.status.idle": "2023-08-25T18:25:34.835452Z", - "shell.execute_reply": "2023-08-25T18:25:34.834556Z" - } - }, - "outputs": [], - "source": [ - "import math\n", - "from qiskit.providers.fake_provider import FakeTokyo\n", - "\n", - "backend = FakeTokyo() # mimics the tokyo device in terms of coupling map and basis gates" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:47:59.632459Z", - "start_time": "2019-12-10T21:47:58.959187Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:34.839582Z", - "iopub.status.busy": "2023-08-25T18:25:34.839114Z", - "iopub.status.idle": "2023-08-25T18:25:34.964569Z", - "shell.execute_reply": "2023-08-25T18:25:34.963877Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
     »\n",
-       "q_0: »\n",
-       "     »\n",
-       "q_1: »\n",
-       "     »\n",
-       "q_2: »\n",
-       "     »\n",
-       "q_3: »\n",
-       "     »\n",
-       "q_4: »\n",
-       "     »\n",
-       "q_5: »\n",
-       "     »\n",
-       "q_6: »\n",
-       "     »\n",
-       "q_7: »\n",
-       "     »\n",
-       "q_8: »\n",
-       "     »\n",
-       "q_9: »\n",
-       "     »\n",
-       "«     ┌────────────────────────────────────────────────────────────────────────────┐\n",
-       "«q_0: ┤0                                                                           ├\n",
-       "«     │                                                                            │\n",
-       "«q_1: ┤1                                                                           ├\n",
-       "«     │  Initialize(0.5j,0.35355,0,0,0,0,0,0,0.35355,0.35355j,0,0,0,0,0.5,0.35355) │\n",
-       "«q_2: ┤2                                                                           ├\n",
-       "«     │                                                                            │\n",
-       "«q_3: ┤3                                                                           ├\n",
-       "«     └────────────────────────────────────────────────────────────────────────────┘\n",
-       "«q_4: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«                                                                                   \n",
-       "«q_5: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«                                                                                   \n",
-       "«q_6: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«                                                                                   \n",
-       "«q_7: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«                                                                                   \n",
-       "«q_8: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«                                                                                   \n",
-       "«q_9: ──────────────────────────────────────────────────────────────────────────────\n",
-       "«
" - ], - "text/plain": [ - " »\n", - "q_0: »\n", - " »\n", - "q_1: »\n", - " »\n", - "q_2: »\n", - " »\n", - "q_3: »\n", - " »\n", - "q_4: »\n", - " »\n", - "q_5: »\n", - " »\n", - "q_6: »\n", - " »\n", - "q_7: »\n", - " »\n", - "q_8: »\n", - " »\n", - "q_9: »\n", - " »\n", - "« ┌────────────────────────────────────────────────────────────────────────────┐\n", - "«q_0: ┤0 ├\n", - "« │ │\n", - "«q_1: ┤1 ├\n", - "« │ Initialize(0.5j,0.35355,0,0,0,0,0,0,0.35355,0.35355j,0,0,0,0,0.5,0.35355) │\n", - "«q_2: ┤2 ├\n", - "« │ │\n", - "«q_3: ┤3 ├\n", - "« └────────────────────────────────────────────────────────────────────────────┘\n", - "«q_4: ──────────────────────────────────────────────────────────────────────────────\n", - "« \n", - "«q_5: ──────────────────────────────────────────────────────────────────────────────\n", - "« \n", - "«q_6: ──────────────────────────────────────────────────────────────────────────────\n", - "« \n", - "«q_7: ──────────────────────────────────────────────────────────────────────────────\n", - "« \n", - "«q_8: ──────────────────────────────────────────────────────────────────────────────\n", - "« \n", - "«q_9: ──────────────────────────────────────────────────────────────────────────────\n", - "« " - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qc = QuantumCircuit(10)\n", - "\n", - "random_state = [\n", - " 1 / math.sqrt(4) * complex(0, 1),\n", - " 1 / math.sqrt(8) * complex(1, 0),\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1 / math.sqrt(8) * complex(1, 0),\n", - " 1 / math.sqrt(8) * complex(0, 1),\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1 / math.sqrt(4) * complex(1, 0),\n", - " 1 / math.sqrt(8) * complex(1, 0)]\n", - "\n", - "qc.initialize(random_state, range(4))\n", - "qc.draw()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now map this to the 20-qubit Tokyo device, with different optimization levels:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:00.000884Z", - "start_time": "2019-12-10T21:47:59.634920Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:34.969668Z", - "iopub.status.busy": "2023-08-25T18:25:34.968324Z", - "iopub.status.idle": "2023-08-25T18:25:35.265698Z", - "shell.execute_reply": "2023-08-25T18:25:35.264985Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gates = OrderedDict([('cx', 70), ('u3', 15), ('u1', 14), ('reset', 4)])\n", - "depth = 86\n" - ] - } - ], - "source": [ - "optimized_0 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=0)\n", - "print('gates = ', optimized_0.count_ops())\n", - "print('depth = ', optimized_0.depth())" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:00.474954Z", - "start_time": "2019-12-10T21:48:00.003129Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:35.270709Z", - "iopub.status.busy": "2023-08-25T18:25:35.269492Z", - "iopub.status.idle": "2023-08-25T18:25:35.360004Z", - "shell.execute_reply": "2023-08-25T18:25:35.359180Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gates = OrderedDict([('cx', 22), ('u3', 15), ('u1', 6), ('reset', 4)])\n", - "depth = 41\n" - ] - } - ], - "source": [ - "optimized_1 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=1)\n", - "print('gates = ', optimized_1.count_ops())\n", - "print('depth = ', optimized_1.depth())" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:01.649048Z", - "start_time": "2019-12-10T21:48:00.477272Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:35.365687Z", - "iopub.status.busy": "2023-08-25T18:25:35.364283Z", - "iopub.status.idle": "2023-08-25T18:25:35.448775Z", - "shell.execute_reply": "2023-08-25T18:25:35.448055Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gates = OrderedDict([('cx', 20), ('u3', 15), ('u1', 6), ('reset', 4)])\n", - "depth = 39\n" - ] - } - ], - "source": [ - "optimized_2 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=2)\n", - "print('gates = ', optimized_2.count_ops())\n", - "print('depth = ', optimized_2.depth())" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.166110Z", - "start_time": "2019-12-10T21:48:01.651535Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:35.453871Z", - "iopub.status.busy": "2023-08-25T18:25:35.452621Z", - "iopub.status.idle": "2023-08-25T18:25:35.560848Z", - "shell.execute_reply": "2023-08-25T18:25:35.559972Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gates = OrderedDict([('cx', 20), ('u3', 15), ('u1', 6), ('reset', 4)])\n", - "depth = 39\n" - ] - } - ], - "source": [ - "optimized_3 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=3)\n", - "print('gates = ', optimized_3.count_ops())\n", - "print('depth = ', optimized_3.depth())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introducing the DAG" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qiskit, we represent circuits internally using a Directed Acyclic Graph (DAG). The advantage of this representation over a pure list of gates (i.e., *netlist*) is that the flow of information between operations are explicit, making it easier for passes to make transformation decisions without changing the semantics of the circuit.\n", - "\n", - "Let's start by building a simple circuit, and examining its DAG." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.375950Z", - "start_time": "2019-12-10T21:48:03.169405Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:35.566793Z", - "iopub.status.busy": "2023-08-25T18:25:35.565393Z", - "iopub.status.idle": "2023-08-25T18:25:35.848730Z", - "shell.execute_reply": "2023-08-25T18:25:35.847981Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", - "from qiskit.dagcircuit import DAGCircuit\n", - "q = QuantumRegister(3, 'q')\n", - "c = ClassicalRegister(3, 'c')\n", - "circ = QuantumCircuit(q, c)\n", - "circ.h(q[0])\n", - "circ.cx(q[0], q[1])\n", - "circ.measure(q[0], c[0])\n", - "circ.rz(0.5, q[1]).c_if(c, 2)\n", - "circ.draw(output='mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the DAG, there are three kinds of graph nodes: qubit/clbit input nodes (green), operation nodes (blue), and output nodes (red). Each edge indicates data flow (or dependency) between two nodes. " - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.525267Z", - "start_time": "2019-12-10T21:48:03.378085Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:35.853022Z", - "iopub.status.busy": "2023-08-25T18:25:35.852563Z", - "iopub.status.idle": "2023-08-25T18:25:37.484757Z", - "shell.execute_reply": "2023-08-25T18:25:37.483965Z" - }, - "scrolled": true - }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Could not save to JPEG for display", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[38;5;241m=\u001b[39m \u001b[43mRAWMODE\u001b[49m\u001b[43m[\u001b[49m\u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage_format\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m \u001b[43msave_handler\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2414\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcannot write mode \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mim\u001b[38;5;241m.\u001b[39mmode\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m as JPEG\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[38;5;241m=\u001b[39m im\u001b[38;5;241m.\u001b[39mencoderinfo\n", - "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_jpeg_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[38;5;124;03m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_repr_image\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mJPEG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not save to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimage_format\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for display\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m b\u001b[38;5;241m.\u001b[39mgetvalue()\n", - "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.converters import circuit_to_dag\n", - "from qiskit.tools.visualization import dag_drawer\n", - "dag = circuit_to_dag(circ)\n", - "dag_drawer(dag)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Therefore, writing a transpiler pass means using Qiskit's DAGCircuit API to analyze or transform the circuit. Let's see some examples of this." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**a. Get all op nodes in the DAG:**" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.532050Z", - "start_time": "2019-12-10T21:48:03.527373Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:37.488355Z", - "iopub.status.busy": "2023-08-25T18:25:37.488077Z", - "iopub.status.idle": "2023-08-25T18:25:37.493016Z", - "shell.execute_reply": "2023-08-25T18:25:37.492403Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[DAGOpNode(op=Instruction(name='h', num_qubits=1, num_clbits=0, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0),), cargs=()),\n", - " DAGOpNode(op=Instruction(name='cx', num_qubits=2, num_clbits=0, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0), Qubit(QuantumRegister(3, 'q'), 1)), cargs=()),\n", - " DAGOpNode(op=Instruction(name='measure', num_qubits=1, num_clbits=1, params=[]), qargs=(Qubit(QuantumRegister(3, 'q'), 0),), cargs=(Clbit(ClassicalRegister(3, 'c'), 0),)),\n", - " DAGOpNode(op=Instruction(name='rz', num_qubits=1, num_clbits=0, params=[0.5]), qargs=(Qubit(QuantumRegister(3, 'q'), 1),), cargs=())]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dag.op_nodes()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Each node is an instance of the ``DAGOpNode`` class. Let's examine the information stored in the fourth op node." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.540054Z", - "start_time": "2019-12-10T21:48:03.534378Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:37.496135Z", - "iopub.status.busy": "2023-08-25T18:25:37.495635Z", - "iopub.status.idle": "2023-08-25T18:25:37.506647Z", - "shell.execute_reply": "2023-08-25T18:25:37.506048Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "node name: rz\n", - "node op: Instruction(name='rz', num_qubits=1, num_clbits=0, params=[0.5])\n", - "node qargs: (Qubit(QuantumRegister(3, 'q'), 1),)\n", - "node cargs: ()\n", - "node condition: (ClassicalRegister(3, 'c'), 2)\n" - ] - } - ], - "source": [ - "node = dag.op_nodes()[3]\n", - "print(\"node name: \", node.name)\n", - "print(\"node op: \", node.op)\n", - "print(\"node qargs: \", node.qargs)\n", - "print(\"node cargs: \", node.cargs)\n", - "print(\"node condition: \", node.op.condition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**b. Add an operation to the back:**" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.660392Z", - "start_time": "2019-12-10T21:48:03.542892Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:37.509619Z", - "iopub.status.busy": "2023-08-25T18:25:37.509390Z", - "iopub.status.idle": "2023-08-25T18:25:37.728942Z", - "shell.execute_reply": "2023-08-25T18:25:37.727978Z" - }, - "tags": [ - "nbsphinx-thumbnail" - ] - }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Could not save to JPEG for display", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[38;5;241m=\u001b[39m \u001b[43mRAWMODE\u001b[49m\u001b[43m[\u001b[49m\u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage_format\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m \u001b[43msave_handler\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2414\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcannot write mode \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mim\u001b[38;5;241m.\u001b[39mmode\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m as JPEG\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[38;5;241m=\u001b[39m im\u001b[38;5;241m.\u001b[39mencoderinfo\n", - "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_jpeg_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[38;5;124;03m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_repr_image\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mJPEG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not save to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimage_format\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for display\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m b\u001b[38;5;241m.\u001b[39mgetvalue()\n", - "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import HGate\n", - "dag.apply_operation_back(HGate(), qargs=[q[0]])\n", - "dag_drawer(dag)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**c. Add an operation to the front:**" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.773434Z", - "start_time": "2019-12-10T21:48:03.662725Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:37.734406Z", - "iopub.status.busy": "2023-08-25T18:25:37.733153Z", - "iopub.status.idle": "2023-08-25T18:25:38.089923Z", - "shell.execute_reply": "2023-08-25T18:25:38.088943Z" - } - }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Could not save to JPEG for display", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[38;5;241m=\u001b[39m \u001b[43mRAWMODE\u001b[49m\u001b[43m[\u001b[49m\u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage_format\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m \u001b[43msave_handler\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2414\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcannot write mode \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mim\u001b[38;5;241m.\u001b[39mmode\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m as JPEG\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[38;5;241m=\u001b[39m im\u001b[38;5;241m.\u001b[39mencoderinfo\n", - "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_jpeg_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[38;5;124;03m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_repr_image\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mJPEG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/work/1/s/.tox/tutorials/lib/python3.8/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not save to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimage_format\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for display\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m b\u001b[38;5;241m.\u001b[39mgetvalue()\n", - "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import CCXGate\n", - "dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]], cargs=[])\n", - "dag_drawer(dag)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**d. Substitute a node with a subcircuit:**" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:03.905653Z", - "start_time": "2019-12-10T21:48:03.776373Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.093916Z", - "iopub.status.busy": "2023-08-25T18:25:38.093527Z", - "iopub.status.idle": "2023-08-25T18:25:38.207711Z", - "shell.execute_reply": "2023-08-25T18:25:38.206862Z" - } - }, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.circuit.library import CHGate, U2Gate, CXGate\n", - "mini_dag = DAGCircuit()\n", - "p = QuantumRegister(2, \"p\")\n", - "mini_dag.add_qreg(p)\n", - "mini_dag.apply_operation_back(CHGate(), qargs=[p[1], p[0]])\n", - "mini_dag.apply_operation_back(U2Gate(0.1, 0.2), qargs=[p[1]])\n", - "\n", - "# substitute the cx node with the above mini-dag\n", - "cx_node = dag.op_nodes(op=CXGate).pop()\n", - "dag.substitute_node_with_dag(node=cx_node, input_dag=mini_dag, wires=[p[0], p[1]])\n", - "dag_drawer(dag)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, after all transformations are complete, we can convert back to a regular QuantumCircuit object.\n", - "This is what the transpiler does! It takes a circuit, operates on it in DAG form, and outputs a transformed circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.154317Z", - "start_time": "2019-12-10T21:48:03.916725Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.213190Z", - "iopub.status.busy": "2023-08-25T18:25:38.211932Z", - "iopub.status.idle": "2023-08-25T18:25:38.468812Z", - "shell.execute_reply": "2023-08-25T18:25:38.468062Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.converters import dag_to_circuit\n", - "circuit = dag_to_circuit(dag)\n", - "circuit.draw(output='mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Implementing a BasicMapper Pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we are familiar with the DAG, let's use it to write a transpiler pass. Here we will implement a basic pass for mapping an arbitrary circuit to a device with limited qubit connectivity. We call this the BasicMapper. This pass is included in Qiskit Terra as well.\n", - "\n", - "The first thing to do when writing a transpiler pass is to decide whether the pass class derives from a ``TransformationPass`` or ``AnalysisPass``. Transformation passes modify the circuit, while analysis passes only collect information about a circuit (to be used by other passes). Then, the ``run(dag)`` method is implemented, which does the main task. Finally, the pass is registered inside the ``qiskit.transpiler.passes`` module.\n", - "\n", - "This pass functions as follows: it traverses the DAG layer-by-layer (each layer is a group of operations acting on independent qubits, so in theory all operations in a layer can be done independently). For each operation, if it does not already meet the coupling map constraints, the pass identifies a swap path and inserts swaps to bring the two qubits close to each other.\n", - "\n", - "Follow the comments in the code for more details." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.178919Z", - "start_time": "2019-12-10T21:48:04.159510Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.474133Z", - "iopub.status.busy": "2023-08-25T18:25:38.472904Z", - "iopub.status.idle": "2023-08-25T18:25:38.504720Z", - "shell.execute_reply": "2023-08-25T18:25:38.503967Z" - } - }, - "outputs": [], - "source": [ - "from copy import copy\n", - "\n", - "from qiskit.transpiler.basepasses import TransformationPass\n", - "from qiskit.transpiler import Layout\n", - "from qiskit.circuit.library import SwapGate\n", - "\n", - "\n", - "class BasicSwap(TransformationPass):\n", - " \"\"\"Maps (with minimum effort) a DAGCircuit onto a `coupling_map` adding swap gates.\"\"\"\n", - "\n", - " def __init__(self,\n", - " coupling_map,\n", - " initial_layout=None):\n", - " \"\"\"Maps a DAGCircuit onto a `coupling_map` using swap gates.\n", - " \n", - " Args:\n", - " coupling_map (CouplingMap): Directed graph represented a coupling map.\n", - " initial_layout (Layout): initial layout of qubits in mapping\n", - " \"\"\"\n", - " super().__init__()\n", - " self.coupling_map = coupling_map\n", - " self.initial_layout = initial_layout\n", - "\n", - " def run(self, dag):\n", - " \"\"\"Runs the BasicSwap pass on `dag`.\n", - " \n", - " Args:\n", - " dag (DAGCircuit): DAG to map.\n", - "\n", - " Returns:\n", - " DAGCircuit: A mapped DAG.\n", - "\n", - " Raises:\n", - " TranspilerError: if the coupling map or the layout are not\n", - " compatible with the DAG.\n", - " \"\"\"\n", - " new_dag = DAGCircuit()\n", - " for qreg in dag.qregs.values():\n", - " new_dag.add_qreg(qreg)\n", - " for creg in dag.cregs.values():\n", - " new_dag.add_creg(creg)\n", - " \n", - "\n", - " if self.initial_layout is None:\n", - " if self.property_set[\"layout\"]:\n", - " self.initial_layout = self.property_set[\"layout\"]\n", - " else:\n", - " self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())\n", - "\n", - " if len(dag.qubits) != len(self.initial_layout):\n", - " raise TranspilerError('The layout does not match the amount of qubits in the DAG')\n", - "\n", - " if len(self.coupling_map.physical_qubits) != len(self.initial_layout):\n", - " raise TranspilerError(\n", - " \"Mappers require to have the layout to be the same size as the coupling map\")\n", - " \n", - " canonical_register = dag.qregs['q']\n", - " trivial_layout = Layout.generate_trivial_layout(canonical_register)\n", - " current_layout = trivial_layout.copy()\n", - "\n", - " for layer in dag.serial_layers():\n", - " subdag = layer['graph']\n", - "\n", - " for gate in subdag.two_qubit_ops():\n", - " physical_q0 = current_layout[gate.qargs[0]]\n", - " physical_q1 = current_layout[gate.qargs[1]]\n", - " if self.coupling_map.distance(physical_q0, physical_q1) != 1:\n", - " # Insert a new layer with the SWAP(s).\n", - " swap_layer = DAGCircuit()\n", - " swap_layer.add_qreg(canonical_register)\n", - "\n", - " path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)\n", - " for swap in range(len(path) - 2):\n", - " connected_wire_1 = path[swap]\n", - " connected_wire_2 = path[swap + 1]\n", - "\n", - " qubit_1 = current_layout[connected_wire_1]\n", - " qubit_2 = current_layout[connected_wire_2]\n", - "\n", - " # create the swap operation\n", - " swap_layer.apply_operation_back(SwapGate(),\n", - " qargs=[qubit_1, qubit_2],\n", - " cargs=[])\n", - "\n", - " # layer insertion\n", - " order = current_layout.reorder_bits(new_dag.qubits)\n", - " new_dag.compose(swap_layer, qubits=order)\n", - "\n", - " # update current_layout\n", - " for swap in range(len(path) - 2):\n", - " current_layout.swap(path[swap], path[swap + 1])\n", - "\n", - " order = current_layout.reorder_bits(new_dag.qubits)\n", - " new_dag.compose(subdag, qubits=order)\n", - "\n", - " return new_dag" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's test this pass on a small example circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.189596Z", - "start_time": "2019-12-10T21:48:04.181850Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.510202Z", - "iopub.status.busy": "2023-08-25T18:25:38.508885Z", - "iopub.status.idle": "2023-08-25T18:25:38.522211Z", - "shell.execute_reply": "2023-08-25T18:25:38.521580Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "q = QuantumRegister(7, 'q')\n", - "in_circ = QuantumCircuit(q)\n", - "in_circ.h(q[0])\n", - "in_circ.cx(q[0], q[4])\n", - "in_circ.cx(q[2], q[3])\n", - "in_circ.cx(q[6], q[1])\n", - "in_circ.cx(q[5], q[0])\n", - "in_circ.rz(0.1, q[2])\n", - "in_circ.cx(q[5], q[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we construct a pass manager that contains our new pass. We pass the example circuit above to this pass manager, and obtain a new, transformed circuit." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.207681Z", - "start_time": "2019-12-10T21:48:04.191604Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.526842Z", - "iopub.status.busy": "2023-08-25T18:25:38.525666Z", - "iopub.status.idle": "2023-08-25T18:25:38.548666Z", - "shell.execute_reply": "2023-08-25T18:25:38.547961Z" - } - }, - "outputs": [], - "source": [ - "from qiskit.transpiler import PassManager\n", - "from qiskit.transpiler import CouplingMap\n", - "from qiskit import BasicAer\n", - "pm = PassManager()\n", - "coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]\n", - "coupling_map = CouplingMap(couplinglist=coupling)\n", - "\n", - "pm.append([BasicSwap(coupling_map)])\n", - "\n", - "out_circ = pm.run(in_circ)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.457320Z", - "start_time": "2019-12-10T21:48:04.210267Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.553696Z", - "iopub.status.busy": "2023-08-25T18:25:38.552485Z", - "iopub.status.idle": "2023-08-25T18:25:38.882683Z", - "shell.execute_reply": "2023-08-25T18:25:38.881873Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "in_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.807143Z", - "start_time": "2019-12-10T21:48:04.459740Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:38.888024Z", - "iopub.status.busy": "2023-08-25T18:25:38.886710Z", - "iopub.status.idle": "2023-08-25T18:25:39.363778Z", - "shell.execute_reply": "2023-08-25T18:25:39.363070Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "out_circ.draw(output='mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that this pass only inserts the swaps necessary to make every two-qubit interaction conform to the device coupling map. It does not, for example, care about the direction of interactions, or the native gate set supported by the device. This is a design philosophy of Qiskit's transpiler: every pass performs a small, well-defined action, and the aggressive circuit optimization is achieved by the pass manager through combining multiple passes." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Transpiler Logging \n", - "\n", - "Due to the complexity of the internal operations that the transpiler is performing it's likely that you'll end up in a situation where you'd like to debug an issue or just understand more of what is happening inside the transpiler when you call it. To facilitate this the transpiler emits log messages as part of its normal operation. This logging uses the Python standard library `logging` module to emit the log messages. Python's standard logging was used because it allows Qiskit-Terra's logging to integrate in a standard way with other applications and libraries.\n", - "\n", - "For a more thorough introduction to Python logging refer to the [official documentation](https://docs.python.org/3/library/logging.html) and the tutorials and cookbook linked off of there." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " Note: Most of the logging module functions used in this section adjust global settings. If you run commands in this section it might effect the output from other cells if they are run in a different order.\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Configuring Python Standard Library Logging\n", - "\n", - "By default Python Standard Logging only prints log messages at the `WARNING`, `ERROR`, or `CRITICAL` log levels.\n", - "Since none of the logs emitted by the transpiler use these log levels (they're all informative) you need to configure logging.\n", - "\n", - "The simplest way to do this is to just run:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.813322Z", - "start_time": "2019-12-10T21:48:04.809390Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:39.369280Z", - "iopub.status.busy": "2023-08-25T18:25:39.368001Z", - "iopub.status.idle": "2023-08-25T18:25:39.373508Z", - "shell.execute_reply": "2023-08-25T18:25:39.372877Z" - } - }, - "outputs": [], - "source": [ - "import logging\n", - "\n", - "logging.basicConfig(level='DEBUG')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `basicConfig()` function (see the docs here: https://docs.python.org/3/library/logging.html#logging.basicConfig) configures a root handler and formatter. We also specify the [log level](https://docs.python.org/3/library/logging.html#levels) to display with the `level` kwarg. Setting it to a level will also include and higher levels. For example, if you set it to `'INFO'`, in addition to the `INFO` level, this will also include the `WARNING`, `ERROR`, and `CRITICAL` log levels.\n", - "\n", - "Now the python environment in this notebook is configured to emit log messages to stderr when you run the transpiler. For example:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " Note: basicConfig() will only work when called the first time it's called. It detects if a root handler and formatter have already been setup (either by using an earlier basicConfig() call or otherwise) and does nothing if they have. Further adjustments will have to by interacting with the handler directly.\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.870900Z", - "start_time": "2019-12-10T21:48:04.815673Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:39.378269Z", - "iopub.status.busy": "2023-08-25T18:25:39.377087Z", - "iopub.status.idle": "2023-08-25T18:25:40.228239Z", - "shell.execute_reply": "2023-08-25T18:25:40.227595Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.02527 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.12302 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.05245 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Unroll3qOrMore - 0.02646 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: SetLayout - 0.01431 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: TrivialLayout - 0.07081 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.05507 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FullAncillaAllocation - 0.12159 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: EnlargeWithAncilla - 0.11563 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ApplyLayout - 0.42582 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.04363 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.11373 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03862 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnrollCustomDefinitions - 0.41223 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule \n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule \n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule \n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule \n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rx generated using rule \n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule \n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:rx/1 => [Parameter(theta)]\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.698s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from \n", - " ┌───┐\n", - "q76: ┤ x ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to\n", - " ┌───────────┐\n", - "q76: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rx/1 [Parameter(theta)] =>\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from \n", - " ┌───┐\n", - "q73: ┤ h ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to\n", - " ┌─────────┐\n", - "q73: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.022s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: BasisTranslator - 722.23139 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckGateDirection - 0.06580 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GateDirection - 0.18215 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.06127 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.02027 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.03624 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01264 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 1.08647 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.06032 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03552 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.03934 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01335 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02670 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01216 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 0.27943 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.04458 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03028 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.03648 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01192 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02432 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01192 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.03123 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.compiler.transpiler:Total Transpile Time - 842.20171 (ms)\n" - ] - } - ], - "source": [ - "from qiskit.providers.fake_provider import FakeTenerife\n", - "\n", - "\n", - "log_circ = QuantumCircuit(2, 2)\n", - "log_circ.h(0)\n", - "log_circ.h(1)\n", - "log_circ.h(1)\n", - "log_circ.x(1)\n", - "log_circ.cx(0, 1)\n", - "log_circ.measure([0,1], [0,1])\n", - "\n", - "backend = FakeTenerife()\n", - "\n", - "transpile(log_circ, backend);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As you can clearly see here when calling `transpile()` it now prints 2 types of log messages. The first is at the `INFO` log level and come from the pass manager. These indicate each pass that was executed and how long that took. The second are at the `DEBUG` level and come from the StochasticSwap pass and describes the internal operation of that pass. It's useful for debugging issues in the pass's operation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Adjusting the log level for the transpiler\n", - "\n", - "The qiskit transpiler uses a single namespace ``qiskit.transpiler``, as used by ``logging.getLogger('qiskit.transpiler')``. This makes it very easy to adjust the log level for just the transpiler. For example if you only wish to see log messages at the INFO level or above you can run:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:04.917836Z", - "start_time": "2019-12-10T21:48:04.872823Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:40.249888Z", - "iopub.status.busy": "2023-08-25T18:25:40.249337Z", - "iopub.status.idle": "2023-08-25T18:25:40.354414Z", - "shell.execute_reply": "2023-08-25T18:25:40.353951Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.02122 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.07987 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.04601 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Unroll3qOrMore - 0.02432 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: SetLayout - 0.01264 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: TrivialLayout - 0.06342 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.04697 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FullAncillaAllocation - 0.11587 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: EnlargeWithAncilla - 0.10896 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ApplyLayout - 0.38004 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.04196 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.10443 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03910 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnrollCustomDefinitions - 0.23103 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.001s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: BasisTranslator - 3.29542 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckGateDirection - 0.05412 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GateDirection - 0.18239 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.05221 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01526 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.04578 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01669 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 1.12319 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.05960 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03552 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.04125 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01359 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02694 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01287 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 0.30375 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.06223 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03552 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.04220 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01216 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02623 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01192 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.03195 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.compiler.transpiler:Total Transpile Time - 100.73042 (ms)\n" - ] - } - ], - "source": [ - "logging.getLogger('qiskit.transpiler').setLevel('INFO')\n", - "transpile(log_circ, backend);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Setting up logging to deal with parallel execution\n", - "\n", - "When running the transpiler with multiple circuits by default these circuits are transpiled in parallel. If you want to do this with logging enabled and be able to understand the output some additional steps are required.\n", - "\n", - "If you were just to enable logging as above and then pass `transpile()` multiple circuits you'll get results that are difficult to decipher. For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:05.069815Z", - "start_time": "2019-12-10T21:48:04.920183Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:40.450222Z", - "iopub.status.busy": "2023-08-25T18:25:40.449218Z", - "iopub.status.idle": "2023-08-25T18:25:40.914454Z", - "shell.execute_reply": "2023-08-25T18:25:40.913807Z" - }, - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:stevedore.extension:found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.02575 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.07677 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03552 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Unroll3qOrMore - 0.02050 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: SetLayout - 0.01073 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: TrivialLayout - 0.05722 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.03743 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FullAncillaAllocation - 0.10443 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: EnlargeWithAncilla - 0.08988 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ApplyLayout - 0.34761 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.03505 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.07844 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03338 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnrollCustomDefinitions - 0.06008 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule \n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule \n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule \n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule \n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rx generated using rule \n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule \n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:rx/1 => [Parameter(theta)]\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.016s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from \n", - " ┌───┐\n", - "q92: ┤ x ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to\n", - " ┌───────────┐\n", - "q92: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rx/1 [Parameter(theta)] =>\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from \n", - " ┌───┐\n", - "q89: ┤ h ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to\n", - " ┌─────────┐\n", - "q89: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.012s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: BasisTranslator - 31.26550 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckGateDirection - 0.06294 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GateDirection - 0.18287 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.05627 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01717 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.03195 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01359 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 1.01113 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.04864 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03672 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.04220 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01216 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02766 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01168 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 0.27442 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.04554 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03147 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.03982 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01121 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02646 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01192 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.03099 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.01454 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.05937 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03552 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Unroll3qOrMore - 0.01955 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: SetLayout - 0.01001 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: TrivialLayout - 0.05031 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.03839 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FullAncillaAllocation - 0.09966 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: EnlargeWithAncilla - 0.08869 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ApplyLayout - 0.33665 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckMap - 0.03624 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnitarySynthesis - 0.08774 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: HighLevelSynthesis - 0.03362 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: UnrollCustomDefinitions - 0.06127 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Begining basis search from {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate u generated using rule \n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate r generated using rule \n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate h generated using rule \n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate p generated using rule \n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate rx generated using rule \n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Gate x generated using rule \n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Transformation path:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:x/1 => []\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:rx/1 => [Parameter(theta)]\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:p/1 => [Parameter(theta)]\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:h/1 => []\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:r/1 => [Parameter(theta), Parameter(phi)]\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation path search completed in 0.017s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: x/1 [] =>\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('x', 1) x, [] from \n", - " ┌───┐\n", - "q96: ┤ x ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('x', 1) x, [] to\n", - " ┌───────────┐\n", - "q96: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: rx/1 [Parameter(theta)] =>\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: p/1 [Parameter(theta)] =>\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: h/1 [] =>\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updating transform for mapped instr ('h', 1) h, [] from \n", - " ┌───┐\n", - "q93: ┤ h ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Updated transform for mapped instr ('h', 1) h, [] to\n", - " ┌─────────┐\n", - "q93: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:qiskit.transpiler.passes.basis.basis_translator:Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation paths composed in 0.012s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.transpiler.passes.basis.basis_translator:Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: BasisTranslator - 31.84676 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CheckGateDirection - 0.06795 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GateDirection - 0.18001 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.05984 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01764 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.03290 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01502 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 1.02520 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.05102 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03767 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.04101 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01311 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02646 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01216 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Optimize1qGatesDecomposition - 0.27895 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: CXCancellation - 0.04435 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: GatesInBasis - 0.03076 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Depth - 0.03934 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01144 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: Size - 0.02575 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: FixedPoint - 0.01097 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.passmanager.passrunner:Pass: ContainsInstruction - 0.03099 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:qiskit.compiler.transpiler:Total Transpile Time - 459.21159 (ms)\n" - ] - } - ], - "source": [ - "# Change log level back to DEBUG\n", - "logging.getLogger('qiskit.transpiler').setLevel('DEBUG')\n", - "# Transpile multiple circuits\n", - "circuits = [log_circ, log_circ]\n", - "transpile(circuits, backend);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As you can see here we get log messages from both circuits being transpiled together. There is no way to know which pass is part of which circuit's transpilation. Luckily Python logging provides tools to deal with this. The simplest one is to just change the [log formatter](https://docs.python.org/3/library/logging.html#logging.Formatter) so that includes additional information so we can associate a log message with the process it came from." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:05.077804Z", - "start_time": "2019-12-10T21:48:05.073526Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:40.965311Z", - "iopub.status.busy": "2023-08-25T18:25:40.964819Z", - "iopub.status.idle": "2023-08-25T18:25:40.970620Z", - "shell.execute_reply": "2023-08-25T18:25:40.969947Z" - } - }, - "outputs": [], - "source": [ - "formatter = logging.Formatter('%(name)s - %(processName)-10s - %(levelname)s: %(message)s')\n", - "handler = logging.getLogger().handlers[0]\n", - "handler.setFormatter(formatter)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then rerun the `transpile()` call and see the new log formatter." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "ExecuteTime": { - "end_time": "2019-12-10T21:48:05.205597Z", - "start_time": "2019-12-10T21:48:05.081153Z" - }, - "execution": { - "iopub.execute_input": "2023-08-25T18:25:40.973810Z", - "iopub.status.busy": "2023-08-25T18:25:40.973461Z", - "iopub.status.idle": "2023-08-25T18:25:41.578367Z", - "shell.execute_reply": "2023-08-25T18:25:41.577893Z" - }, - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager', group='qiskit.transpiler.init')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='dense', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DenseLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='noise_adaptive', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoiseAdaptiveLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='trivial', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:TrivialLayoutPassManager', group='qiskit.transpiler.layout')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='basic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='lookahead', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:LookaheadSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='none', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:NoneRoutingPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='sabre', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:SabreSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='stochastic', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:StochasticSwapPassManager', group='qiskit.transpiler.routing')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='synthesis', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnitarySynthesisPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='translator', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:BasisTranslatorPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='unroller', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:UnrollerPassManager', group='qiskit.transpiler.translation')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:OptimizationPassManager', group='qiskit.transpiler.optimization')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='alap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AlapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='asap', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:AsapSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='default', value='qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultSchedulingPassManager', group='qiskit.transpiler.scheduling')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.ag', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.bm', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.greedy', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.layers', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='clifford.lnn', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='linear_function.pmh', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.acg', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.basic', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.default', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "stevedore.extension - MainProcess - DEBUG: found extension EntryPoint(name='permutation.kms', value='qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation', group='qiskit.synthesis')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ContainsInstruction - 0.02432 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnitarySynthesis - 0.09656 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: HighLevelSynthesis - 0.05364 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Unroll3qOrMore - 0.02170 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: SetLayout - 0.01454 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: TrivialLayout - 0.06270 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckMap - 0.05245 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FullAncillaAllocation - 0.12374 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: EnlargeWithAncilla - 0.11754 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ApplyLayout - 0.36788 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckMap - 0.04435 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnitarySynthesis - 0.09680 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: HighLevelSynthesis - 0.04268 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnrollCustomDefinitions - 0.06890 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Begining basis search from {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate u generated using rule \n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate r generated using rule \n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate h generated using rule \n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate p generated using rule \n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate rx generated using rule \n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate x generated using rule \n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Transformation path:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: x/1 => []\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: rx/1 => [Parameter(theta)]\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: p/1 => [Parameter(theta)]\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: h/1 => []\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: r/1 => [Parameter(theta), Parameter(phi)]\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation path search completed in 0.026s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: x/1 [] =>\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updating transform for mapped instr ('x', 1) x, [] from \n", - " ┌───┐\n", - "q104: ┤ x ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updated transform for mapped instr ('x', 1) x, [] to\n", - " ┌───────────┐\n", - "q104: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: rx/1 [Parameter(theta)] =>\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: p/1 [Parameter(theta)] =>\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: h/1 [] =>\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updating transform for mapped instr ('h', 1) h, [] from \n", - " ┌───┐\n", - "q101: ┤ h ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updated transform for mapped instr ('h', 1) h, [] to\n", - " ┌─────────┐\n", - "q101: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation paths composed in 0.019s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: BasisTranslator - 47.47343 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckGateDirection - 0.07129 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GateDirection - 0.19956 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.06771 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01836 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.04053 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01669 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Optimize1qGatesDecomposition - 1.08838 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CXCancellation - 0.05770 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GatesInBasis - 0.04220 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.04721 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01526 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.03314 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01526 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Optimize1qGatesDecomposition - 0.31447 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CXCancellation - 0.05436 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GatesInBasis - 0.03982 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.04649 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01407 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.03171 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01407 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ContainsInstruction - 0.03719 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ContainsInstruction - 0.01597 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnitarySynthesis - 0.06342 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: HighLevelSynthesis - 0.03839 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Unroll3qOrMore - 0.02265 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: SetLayout - 0.01025 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: TrivialLayout - 0.05293 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckMap - 0.04387 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FullAncillaAllocation - 0.11039 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: EnlargeWithAncilla - 0.10037 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ApplyLayout - 0.34881 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckMap - 0.04029 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnitarySynthesis - 0.08535 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: HighLevelSynthesis - 0.03815 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: UnrollCustomDefinitions - 0.06866 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Begin BasisTranslator from source basis {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to target basis {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Begining basis search from {('h', 1), ('measure', 1), ('cx', 2), ('x', 1)} to {'reset', 'u2', 'measure', 'snapshot', 'id', 'u1', 'delay', 'u3', 'barrier', 'cx'}.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate u generated using rule \n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate r generated using rule \n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate h generated using rule \n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate p generated using rule \n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate rx generated using rule \n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Gate x generated using rule \n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n", - " with total cost of 1.0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Transformation path:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: x/1 => []\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: rx/1 => [Parameter(theta)]\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: p/1 => [Parameter(theta)]\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: h/1 => []\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: r/1 => [Parameter(theta), Parameter(phi)]\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: u/1 => [Parameter(theta), Parameter(phi), Parameter(lam)]\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation path search completed in 0.020s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: x/1 [] =>\n", - " ┌───────────┐\n", - "q: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updating transform for mapped instr ('x', 1) x, [] from \n", - " ┌───┐\n", - "q108: ┤ x ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updated transform for mapped instr ('x', 1) x, [] to\n", - " ┌───────────┐\n", - "q108: ┤ U3(π,0,π) ├\n", - " └───────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: rx/1 [Parameter(theta)] =>\n", - " ┌────────────┐\n", - "q: ┤ R(theta,0) ├\n", - " └────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: p/1 [Parameter(theta)] =>\n", - " ┌──────────────┐\n", - "q: ┤ U(0,0,theta) ├\n", - " └──────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: h/1 [] =>\n", - " ┌─────────┐\n", - "q: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updating transform for mapped instr ('h', 1) h, [] from \n", - " ┌───┐\n", - "q105: ┤ h ├\n", - " └───┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Updated transform for mapped instr ('h', 1) h, [] to\n", - " ┌─────────┐\n", - "q105: ┤ U2(0,π) ├\n", - " └─────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: r/1 [Parameter(theta), Parameter(phi)] =>\n", - " ┌───────────────────────────────────┐\n", - "q: ┤ U3(theta,phi - π/2,π/2 - 1.0*phi) ├\n", - " └───────────────────────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - DEBUG: Composing transform step: u/1 [Parameter(theta), Parameter(phi), Parameter(lam)] =>\n", - " ┌───────────────────┐\n", - "q: ┤ U3(theta,phi,lam) ├\n", - " └───────────────────┘\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation paths composed in 0.027s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.transpiler.passes.basis.basis_translator - MainProcess - INFO: Basis translation instructions replaced in 0.000s.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: BasisTranslator - 49.36886 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CheckGateDirection - 0.07153 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GateDirection - 0.18787 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.06032 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01717 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.03386 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01168 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Optimize1qGatesDecomposition - 1.03378 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CXCancellation - 0.05388 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GatesInBasis - 0.03767 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.04673 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01335 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.02694 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01144 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Optimize1qGatesDecomposition - 0.28086 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: CXCancellation - 0.04649 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: GatesInBasis - 0.03099 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Depth - 0.03934 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01144 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: Size - 0.02599 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: FixedPoint - 0.01121 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.passmanager.passrunner - MainProcess - INFO: Pass: ContainsInstruction - 0.03076 (ms)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "qiskit.compiler.transpiler - MainProcess - INFO: Total Transpile Time - 585.16884 (ms)\n" - ] - } - ], - "source": [ - "transpile(circuits, backend);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now the format for the log messages has been changed and it includes a process name for each of the transpilation processes so it's at least clear which log messages go together.\n", - "\n", - "There are many different options for how you can configure, this example is pretty limited. Refer to the documentation for more examples and options to build more sophisticated use cases that suit your specific use case or preferences." - ] - } - ], - "metadata": { - "celltoolbar": "Tags", - "description": "Transpiler passes and pass manager notebook", - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.17" - }, - "title": "Transpiler passes and pass manager", - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - }, - "vscode": { - "interpreter": { - "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" - } - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "2a78c65199f8464cad8e826f476ab169": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e8a0db65f2d94080898ff75d01662e2b", - "placeholder": "​", - "style": "IPY_MODEL_e8b43570a48c4466aff6c1b286c6383e", - "tabbable": null, - "tooltip": null, - "value": "

Circuit Properties

" - } - }, - "e8a0db65f2d94080898ff75d01662e2b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": "0px 0px 10px 0px", - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e8b43570a48c4466aff6c1b286c6383e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index 1421a513d63..2e0e08686e5 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -4,10 +4,6 @@ { "title": "Introduction", "url": "/transpile" - }, - { - "title": "Introduction to the Transpiler", - "url": "/transpile/transpiler-introduction" } ] } From 95f78389fa4365735d98a014dc61c3793ca31861 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Tue, 31 Oct 2023 13:54:39 -0400 Subject: [PATCH 05/48] Updated introduction --- docs/transpile/index.mdx | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 9dd87359c20..421253007f3 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -11,15 +11,22 @@ Transpilation is the process of rewriting a given input circuit to match the top A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. -This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in st using the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-error-suppression) +This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in st using the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-runtime-compilation) -## Transformation passes -For more advanced users, it is important to understand the various representations of quantum circuits that are used for the transpilation step along with the transformations (i.e., *passes*) that affect the efficiency of the final circuit that is sent to the backend. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: + +## Default Transpilation +The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`](../api/qiskit/qiskit.compiler) function. This will generate one of the present `PassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. Each of these preset `PassMangers` are composed of six basic stages: 1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. 1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. 1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. 1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). -1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. \ No newline at end of file +1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. + +Each of the preset pass managers include these steps and the primary difference between them are the specific that are called at each stage, set by the `optimization_level` flag. + +## Customizing Passes +For more advanced users, one can customize their own set of `PassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling one's quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: + From 629e5a56b18cc4decce043bb8d364e370537b814 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Tue, 31 Oct 2023 17:16:54 -0400 Subject: [PATCH 06/48] Progress on PR 260 --- docs/transpile/index.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 421253007f3..f81bac02fb9 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -9,14 +9,14 @@ description: Introduction to the transpiler Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. -A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits. +A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler allows one to begin approaching utility scale work while keeping noise manageable. This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in st using the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-runtime-compilation) ## Default Transpilation -The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`](../api/qiskit/qiskit.compiler) function. This will generate one of the present `PassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. Each of these preset `PassMangers` are composed of six basic stages: +The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`](../api/qiskit/compiler#compilation-routines) function. This will generate one of the present `PassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. Each of these preset `PassMangers` are composed of six basic stages: 1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. @@ -28,5 +28,5 @@ The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`]( Each of the preset pass managers include these steps and the primary difference between them are the specific that are called at each stage, set by the `optimization_level` flag. ## Customizing Passes -For more advanced users, one can customize their own set of `PassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling one's quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing your own set of passes is by looking to the default sequence of transformations: +For more advanced users, one can customize their own set of `PassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling one's quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is by looking to the default sequence of transformations: From b7f4555e2db5036c8d121bd406f73759e1f5d1c8 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Tue, 31 Oct 2023 17:22:24 -0400 Subject: [PATCH 07/48] Fixed typo --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index f81bac02fb9..e91df258ea9 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -23,7 +23,7 @@ The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`]( 1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. 1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. 1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). -1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. +1. `scheduling` - This pass is for any hardware-aware optimizations that improves the efficiency of the executed microwave pulse instructions. Each of the preset pass managers include these steps and the primary difference between them are the specific that are called at each stage, set by the `optimization_level` flag. From 69ea37e45977a62c7e94682d27035ac2d4f3ba5b Mon Sep 17 00:00:00 2001 From: kaelynj Date: Wed, 1 Nov 2023 16:48:53 -0400 Subject: [PATCH 08/48] Initial draft of preset passmangers page --- docs/transpile/_toc.json | 4 + docs/transpile/passmanagers.ipynb | 168 +++++++++++++++++++++ public/images/transpile/layout-mapping.png | Bin 0 -> 60165 bytes 3 files changed, 172 insertions(+) create mode 100644 docs/transpile/passmanagers.ipynb create mode 100644 public/images/transpile/layout-mapping.png diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index 2e0e08686e5..c09c82e6d57 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -4,6 +4,10 @@ { "title": "Introduction", "url": "/transpile" + }, + { + "title": "Preset PassManagers", + "url": "/transpile/passmanagers" } ] } diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb new file mode 100644 index 00000000000..61ae3670224 --- /dev/null +++ b/docs/transpile/passmanagers.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transpiler Stages & Preset PassManagers\n", + "\n", + "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of different `Passes` which can include things like transforming the operations in your quantum circuit, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise. In the document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", + "\n", + "There are 4 optimization levels ranging from 0 to 3, where higher optimization levels take more time and computational effort but may yield a more optimal circuit. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic based, spending more computational effort does not always result in an improvement in the quality of the output circuit.\n", + "\n", + "When the `transpile()` function is called, a `StagedPassManager` object is created and then executed. This is an object which will orchestrate a series of `PassManagers` containing one or more `Passes` and separated in stages. Think of the `StagedpassManager` as the conductor of an orchestra, the `PassManagers` as the different instrument sections, and `Passes` as the individual musicians. The `StagedPassManager` specify which `PassManagers` is executed at what time. The stages of the preset passmangers are again:\n", + "\n", + "\n", + "1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates.\n", + "1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend.\n", + "1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map.\n", + "1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions.\n", + "1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth).\n", + "1. `scheduling` - This pass is for any hardware-aware optimizations that improves the efficiency of the executed microwave pulse instructions.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Init Stage\n", + "\n", + "The first stage of the preset `PassManagers` will translate (or *unroll*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step as it allows the circuit to be executed by the backend, but will typically lead to an increase in the depth and the number of gates.\n", + "\n", + "There two special cases which are especially important to highlight, and illustrate a bit more clearly what this stage does:\n", + "\n", + "1. If a swap gate is not a native gate to the target backend, this requires three CNOT gates:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rz', 'sx', 'x', 'ecr', 'measure', 'delay']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.providers.fake_provider import FakeSherbrooke\n", + "from qiskit import QuantumCircuit\n", + "\n", + "backend = FakeSherbrooke()\n", + "print(backend.operation_names)\n", + "qc = QuantumCircuit(2)\n", + "qc.swap(0, 1)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of swap gates in a circuit is a primary goal in the process of transpilation.\n", + "\n", + "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate. Given that our basis gate set includes only single and two-qubit gates, it is obvious that this operation must be decomposed. However it is quite costly:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rz', 'sx', 'x', 'ecr', 'measure', 'delay']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "qc = QuantumCircuit(3)\n", + "qc.ccx(0, 1, 2)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates, and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affect by noise.\n", + "\n", + "## Layout Stage\n", + "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. In order to execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device. This mapping is stored as a `Layout` object.\n", + "\n", + "\n", + "![Qubit Mapping](../../public/images/transpile/layout-mapping.png)\n", + "\n", + "The choice of mapping is extremely important for minimizing the number of swap operations needed to map the input circuit onto the device topology ancd ensure the most well-calibrated qubits are utilized. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves 2 steps: first, trying to find a \"perfect\" layout (a layout which does not require any swap operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are 2 `Passes` typically used for this first step:\n", + "\n", + "- `TrivialLayout`: Naively maps each virtual qubit to same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", + "- `VF2Layout`: This is an `AnalysisPass` which works to select an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", + "\n", + "Then for the heuristic stage, 2 passes are used by default:\n", + "\n", + "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", + "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. More details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "description": "Overview of transpiler stages and the PassManager", + "kernelspec": { + "display_name": "qiskit-wKX2ZNlv-py3.11", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "title": "Transpiler Stages & the PassManager" + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/public/images/transpile/layout-mapping.png b/public/images/transpile/layout-mapping.png new file mode 100644 index 0000000000000000000000000000000000000000..eb9797f84dea3125b58c548548702f9b38a8debb GIT binary patch literal 60165 zcmc$`cRbba8$WLE8A8M{vJyfZd#{u|3z3zw_s&Yxv6W4BN=8yvva+3HWn_nAMjROt zzxzeKKkv`?^ZPy?zyE%{>U9q8*L~mD^SZ9*^}Oy=MeAs(k&|2?!NS5K*HBm1!@?ps z!otFBBEkXR@#fcnV_~iKYA7oh_+qb5;Z`{BjaO_{qoT762AE#IcbaexuN!LDa+-Mm zU98%P<9&?Bh`2{k@Sb#lH-)=c@Tbb9t*Ww<$u$-*+5f-4LLO24f7(DuwR_BZcE-|% zpKo@e()M7(wM|q9<{(gJrU$iMe{`jzH2&cN<$+&gj>`h+fwFA;howace(fF(57eaa zXzz1V?p8hmXr-v^JZ|Wy^{Ex$FK<6);brn!Ora7njT-#gk8 zf*&hy>D$w6=uOk}S}&F)j_tC*%O~BojH6V~7i$6qH+wMK5tD2awtTqIpk9eQ?z0v6 z`vhuTD0=HL`I*lyi;QKZe?k`@+>(9%0bMA;soiCb>7Nw$>2vZJG83=2si%AEQI?gl zAXclnk@R?>(oc_~`zZz;$a$wL4wI6Zd0B+{PW&CTk_0;?vfA3_)Nup)JG3&`U`@-P zW9&Z2;{(g!oTnmXdOaR@gHyE^eoF8MptEbO-uDjrekpRVHWT;hnRj=!NQy((OK_#w zn-vP6?qEuo69Vkl$Y`K>LY8Y&qfbq(aN5XOLRU#}&GWe%1*gX?7W!S^$eyaQAQ*|S zeyhKc{BgS_P)M$qm(e&uA5+~RN{MndtyxQi5TKHwKHJsQr10S)jfCv{bt&1I&Na-t z$*Z^REJMGtf9SUGvu#X%XlL5~%+;%t3+{2#q`H{DUqa@!puy!N13UVwwvpjr^_13@8Av4fagN`Fd+>B zpL(_tRqv%Ab_Hw~n2Bo&_gYn0vpf@Dps(ehr}K22PT{sW^vx#5!iHff{C%)wl2Z+> zX8Qbco#*mxKZT8FSA?6wsuY}4!ZG8S30ow;9#~}5+kYeji+~t}`9pck&whJ>+V755 z7yLoWLcO1}bB@=2ESkTTwZ&1w3nmMTI+sbs)P;MK%rx6|rCR{#YkO<7X& z)7?n?DS~C(KRC%ri0+XPoG<--rM&OrTTuvvrd4i#oYPorx?ZDUkt}DQS)H_h#ZFf+fk0$*r|_4y0S2J%t>zN z1-j@l%Z|x&B+$%MGT5h3&l33g*~!%f`%h;b+Dwr>B`~?WTa2i3wUT{)XrD!P!U|0f zZ3ps@cUQuJN4qIppd59vN;F&BGLAVt$2Rj()ppsWM57@X5%QV-&%~BP(h_oAaMI!h z@>;_p;a;33ZwaAKNH{6?;Hd!8^XVpZw`yn1%Gg`nFs)W9!U|Y8I0$Gr z-FL{&yeYyj1`S^(j)JnHso{fpZ1*Q&n5bg6HQfm5lQP1S>dwx*mJzwln_bM)ip?jzFV9=$+aa;2qu@~IvoWX9zOe6r9gmX^!4U;nOUk^7-qX}JsH}liOv8G zfB?J`>%*216DjBZ6}S;^bq#lxPePj8Hq+8nHfzErRS66L!{m1|Wx%_dTNcSxB3iBr z(}~yWvx!2yw)c;?<`KcE0rsgx;OAg*WmGMAgY~}efrmmnu~zq7?e$0r;t;9Dr>5C% zVKZoI({w9xC?0{UPQB&bCFQQsPJA5CZIeZY)qA;q=}j%qJl;c;Y_0nz4A|=F@?fJO zYiN#I>3KZ49$evP*dh2lx%CrFX%UAiGZ!yr~+~)!WedO{(@mqzd2` z4;!r>c(a3q5R(nGx4$bJ^=}-gKex@C)vPs)R3Qr?$E-60FX+F$GlCLg1OtJ8P6IIB zeEayuExmWrtSE9}tR~Slo6RGRc|7h#Q&Yj#6Nn~&8&5sC9`CdG7C{pzIoc;g*km^@ zA>KEI>6DgHLtpbVmd!+=*A5hd)8v+BB)B@z`5H z6_3}_e1r>M4(>IkJX~l&Jnj8_pdFl!TD&3wr|ju-|4HUSR+<&$exsc@woleH9SQ_x zZDmwcb_G>FRGuA^m(WLG|5wCO6^fR86N@Z~~OVn4$*Qq1~o5A7$s1d&VSBfKA7G{P(v`@4Jj@Rp0k|k6#)^#<)M7l=VR=Rr&0q zFqpaq@tnT6ZIqdW!+rsCmbhK{B+r_SiIe4&vOcyqaX3fV!9rAAqr+LGacHxgNMJu5qB(c14OMQ^_Q?y+p+RD!eIdv;PN!_LHMj9nbbvE2|T{R#D%(YWRFft5uz z;le7T5sqVa%3>a3h`%SG$~;m6^2`7Ybe$59ch{0IX7)!_)tFI2g|~CM{i3ymz~xUn z=nTK0?92%?A7d)_bGy+=LA3?_1E2P1KlU2L<9fsx%V1+-o860y#kD+w$acmu12An= zHgugPN`;0+f~K&Rhm}RD(Ps)W#eC^*OD`qP=#e0Jf z?jrkq@w2kZ(Jv=ujC-)Eykn$=%6sEL;+x)no`aUCb>p|Nw)@aUDWdh`^`tBm<&d0% zHVWRB3V%SAgP&wg!dh`!3^B`rLdCY9M>-n>wUJ&`b&qANrY0pHFD;v8x{YXcPI$~X z#$y-x`5q^^g=yOsL#6-BVhgL&>DE)VLA1>HsS}`UOD09t7P(EIyNw(td|0BcRgIJ& z7(tn129MaQ9-{6f3!dHW^<+XQrv$YHB?*psezSDJCE^5y6Ylrj0aeoTqTGvD zA)0{_N8wC=&7OF~9m&j#_F$$RpN0C_4oM5MqWsc=+9V_i(O*FsF-f05FCOUIoe=-h zW66mT;lDcxp8?^$=RWlxJKw6GCiBTNZ9r}vwGIU6=+`zmftONjc9qsPJHzi*65M#} zLD7p6LAKx@SZ<_WVmyC|<+(M81XGKo&s$Dls(+jKRf1>9J`=sOo>W5S!N9b1^*~Rc z4^H|Cg>erjyNo?{m2i(t$0(L4i5Fx>rN~f`T08Uv?IknpG}H6uj?~h>z-Y zjn#BI1}L872FcN$3L-51S`XO-jr_iop-X-)WjR&~^OX`;=0%H_wx9@tIQ-fv(ttP0 za)3fZZ#VEU*_bGe!2;05K!rHSCLP*;_vHd5!Z)@Hp6{|Ko7P=1>-wcZZXR!@SK#j~ zUx@y+5hHz1Jxtpjf|D}9EHzrw@m0VgaX)XnDt{bH2bSlo_L&1YnEldcR?Tw)2lnj_ z0^PY=EN6SsmOqPTlP}JRa(08Zy==AHg4QONDf{-oBu5P*ulclbC)rth7J+|#veSPG z^TSGWQtSq)R|L=E7~rx*f&0aGLpu}_i^5LHcN;B#gS8NKScJLylL0Z z7TE=F){uZP*_w!!$~17QwdL}jdB=h}DUu58ovP(SCC zKtU182B~R~M9SKb=Cg4-MKx9_gM8 zZDMLlv)HhXw3!y8GBe!L7yTX{Uv6#qY_N+eXl)U+?E!E!*+8lD$G^QAd!5l~?~djO z7>#(ndjde<5;vvCwbu1?x58Z4mD98>C3#3Vgz}N z1(Y;-n&{46U1^FH-Q2AM9Y_~GsP%%RGs{6B&`T%|k>1;-Nh$V&<=+FUG=SPZjq3s-%c=1 zoVyOTeR`|{%>+2ePxcuoL)&d+rSGm_BFz#taxqD@!30?7kQhw2S-M-gew97w%ao+y z#emJF#>HCi1L5+o8C+lAsB=0ItkNVfYBAj2Hj8%)6I5QtOFb-0bFs;sl^U06m2Ml6 zkenB_UpQto0-SN`%|8%ak`PULzSJPLW@GutF}~G93n1|9woU3|EMHeZIenk~w9xY| zmo?pexqkcjTaWYr7er-WR)@Na)5C}Ny#)#lLmo3^rSXO1m$|`;9ku$A_}C%j+le=> zTR%iPiS#N>3ZEe1eVguY$c+Dn+UWFmFX$>Dq2$vJf;!+;Lq7 z1X$-|F8Qe<``~@VwLX!4Q6E8L;~<+1!W{SzB;}tVJQ6hS8x>ypwn_n1*L#%OTTtNb z(IKT7bKUqyl)D?Dn%f?vHTw>GuzbYb3>t06iTB*^%Nfl@YNDL%?@qk$Q_!wk^Bev8 z^Oxz0VbaP*$-^(lK@s0drq*^6UiI_Woa24$aTPCD(UeG=&DNrcJ*tjNBaxF)CMG+P zGrt%C?iz{h-!2yP_A$i1OeL7LPmM@ULktPgvT5j1+@8fP=&c{a%2jmexRW4EQ*l`l z8b2_!%&Q^nKXNg@7<^TrbQS-gIgd4;I+sM$lD^?_GVfeqZ*)9o$=z00>~rq+)h zUS=4y%U^9q`wYAoyz{Crb#_}g3wk#P5HH>TvHtG{i0`$msHeG9Tv4PmVG?Awy$+|W zVlSf6NK~C8DCkv2D81Bq-qfR>R)6(^?ia9ofcb#_KgbWdPR1ttQINvw3QgUJ^(ZK< z`SZHf6FsT8*lf!>cp^ydQVFPZHxP1z34zZH-~9VohKA_mT4r48?p*wiS+H^YG5VM& zJ}!;H7T^Z*g#BOf^li1+gyGEt(vdEmA@1Y=YfWkNus%E;Bm$0EY<{KjeDE zL|m&@DXo}TkX|7sE8jgCnns16JHADvhow#|Yw4_N;%=tcVk2igfVRE*W%Y;LG_ zH;@^B#!(b>wPAXsd6k|E$Veuc&=(Vy#XY$J$57`0>6 z(|Gq8zfuG9INV6}&{z1wd5B`#KdPr43X!m#It)rOMj6|kWUvXo!N?Pst;J_WqL+@a zg_r$QSs(!960o|A{IJ9>)uzpegyZiYR#l!lPw#oL%I0X;N_W6ZKHNIf~E zQg>hk9W{RL!4DigGzpoqI>6{Ox5533`Ki^hD#XOLcPuaBiE<#76gQ-Mqn4EtZwcXv zSX=Nv`Fxc?(^>-Y`ML?dbtT#JCdE{G4@)~T6%oZjPj{k5B}G$0Zzb9Yf_aci`l;l9 zG1a>XGFaFj=ZpauPvpBB5cpL6Mf+5|7#1;APfa}zRVxk0D04T4;3sl(IFk{Nw@9Wt zQuZkv>e8bqw@6qzvT6wI=SSf|53f1JPyd34^@!2P_7eOAsRn`*$y!27=ks$+bCbkt(Et zr6Vo3)zdyyP$<6At-5=W86o#gQu-;ex}mkOZ0m$CHELEvI`Z)r*2ZUZo_f|e@YUm# zErRLKDa*>~WpzI!om)1qQarFWiZCD~_;$UZ*CUk)q%(dFaAib36tfVEJM1JwbP7?i z{Z)tzc^l%AB^YI||K3tdju&3KOO+Q=pxXQRjVn8{HGiMrW7d*v+k6enNqZWcnDA~u zX?WpPN>ytD(cBBNN~%^Ci01oa%!jkeM-=q4M$*xgx{9m#IabohCTEj#Z-`2`L}%#% z(^vB4!9)cu6uXaT`l9%_|BxbtGRPN**yRBb8MC)Jlf5jt_jzJI1OB9}2_*(j!;9fVs|{D;|KQO>dlmkJ9?qrj2B(H3*HTx(enkvN*t){Ynz+^F z)CsejYT;zBt$A?toT)}yqHE6Qz-|^&OvbQU`-!p_tlXz^R_UHZC`5(zzwbmD-fTld zh5S@S4CoJqo&_+V_k!jcTwV|2uhd=+@G{lz8*QOc797=9hM5r=TjYZVt1Uxt(nCw) zcd!BrAxiHS)-BQN>U4(;C(XM;9S{5+nkCfJiiIxc!QSD>Djt8Apny{TEI)uTKdJxN zlFkSvi9Bwez?(SAcwuczwuoV+3l*HPEjLp`M4wH!F2c{hwuULby3ksA?HI9?z&8>d z;L49yQV&|D1%k!|PnRm4Ns!GpIEDaX`9FR+W$II+|9F?J;ZelfbFqrUh2BRjmlons zCHGX+hb*<$W1jvX9yIXBx3?DWjp2bihby+r1I- ztEwE&TjREb08G9ta-Z{vO6W^N%j0w8CmD39Rv*8P7ye*PmDl-iBQE9J(+NRT<=}Bc zS#f;Sgh@ALw;d0vn2|3-L}_;07WXfd+})ftTaVHuTHuUn+o&N(O5pp!8QXLZ0Qp=w zn08BQJ(h>)+BX#N$5m3O`a`^4ln&5=67*C-ypxkm(AmXqhpqO)%p#Hx&Ihm;IA4in zoxhqK&-a6_tVO|uip?RNyd|~kKkC;xJ_@BJ| zn;T%-|M);o5zu-qm6x4qLu9fa4k=8B>)KtF%*fGrzFq0yr(gOJ@x$B%mP}?(y40tB zU9h(@ZKGt5X_;3~8yX1VA^IM{tIl(X^O_yfY*3zqDtwxDr&U7*_c$ckkEm7GC9W$W zH7xmn2C%gH6%)#bt%T}ysS!+WRIf0UWQmcMtdrsA^ggh31T#dvOcf=XPY_Ty+-IuB9>NT*;9LFE@%t`BzQcaHfnG zHJid39&`@?vMuEg%e>x@LpQ2k+PNOeI`1L;=IFR#7L z!jo&Meu_z!KiP{H-m~(KSiQkv^!d(@t9tm;&8!s!=~UOQ4|eYhaSvWr8!gJT- zI1Wv&rT7lgH`AAq*FzNN{{@r+e_=huTG~wr|5}HrWkl zFCCHe`Nvkw<~&RrP3Iki>Wl+bG8K}4Uu>5xNXYCCUeK!W6ZaHM3-V$IP8v zVqK--h@WoQTc~9Vod6UiSHExQv$U7Kk z3F?|9$7Ja6o3%>zz@2wYP_jusNtOLcTF{%s0NN{!S4L1$f)>tZCjyENG+=?}9rPgV z2_CSoHnsRt^J0Y1^0b+^Dla;#5SQGhoRcS0Qr9!QMLo*lwPxh&cyr>L6le0skbx-0 z0jo~#%oHJ}Jgh%l0^m4p(N0^$*K-dRG$(t&tYZ5Fyco52>?E3`^JIZx!*4!pY4V5g zz%(v|_vk1pZt(Fx(J}veVJ1b^UXk{Rx9V|bW3(SNL?9?Wkb)pjpshl1B)${iV$WUY z;E#Rja1&0)i@Ek*i8lUgg~*1|>Ikh_?9YKHc`Zr2H$==a@^T0zpnTYl2(#4F1Tr7{ zQN0qm&4#iO%!^vl&#)Fg*FD|A4pk(mR-EaXzxiUAa5I5YX46VR`6g57mU*LW7_oY%*WCTmrvwqh56(A75;=xFqJrZ&MJXnTHF>Ca%0$so zU%Q#XuAQT8#gM1-PH0*UX!!T?|CsWM9)#6DTy_yOzs#-F*Y0ykMTx%XHaK)uyk zM}T}dBOL?EKg#E{?UDqoFjge&{;<0*B`-$s9f!fSua)%K3acaGWB5){vfOW??eIoa zUf@4~6#n4eG&?sKB=k{dFT@NNxrhQ`f`Kdb3S_{j6BJ3wt{+Wn_s!2h9 zg0PPj>~8us82!Cv+tA2f=Tt<*+f5+~^0ZVfQ4+c44glM?yQLxVuiDwiutH-hU^s-i zbXWT>{L)dMN@q#|7IR8_7`)z92C)0QV9nDJJ*N#R^&o0|a9jiF69~7Zoqu5miU2Nd zzkV)XE{6x9WYHj}r@^|n=ZjJrUj3G}J*2iLO_>Hfs2iRn*V5ur3Hk4S^m3EZ`>@e&cMm9hQHE9_rbtU~vd=L7 zC#oRN4W0@43}TA_dRhlEbi?E%WrTTikx z=9oB>pShl6x87NIx;cie4P!HIF=Tkk!|&kpj=e$<=ld94f{6bsq+^(Pg7BSrEQZhb zTgwxK?O`P9xNhQlXgoak$5!kF?0<4Czt|w_EZ0yh)=-lyiO=gndTJAf!ISMI?Hw|w>zCeTUdXCUuG3g$1*aT}QaIJrGPm78Gf&5l2pOpQP;K?F zAv$7m6i!zKD@d=pnod2&9BSl9G&}^2z96=gGPB3#0Nz2S~Sq{-e4CHLJ5n=7B$pd4HK^jODp8B>|i+UCY0u} z9aIqpLui$UWGzPw2<%isj`+t+`NhMrcjlxDdYw|~z?v#7oplv5INxh%iIWB>bNPm1 znScbm5~u}EvCbU#D)vtU0Bp#bfH>kWq z9RzaVjE->tP5z;NPK{NC#}J@Qc_{MM!YGz%*+#|2U!L$hweQitseTl9R_@ah*M7K4 z@tvqd;9?k{Wz`p~?QH(T4~3-i=yzJL0S2o6HoC0XZHBM{MMg;aY2dVG=kN2na2B)Q z!St{vT4&3uqP`{li=YQZ86GFslKa{5{qjF#15#~#bc|?#)XZh`F~`=`bMECs zW<&8I-V+v?j334Yy%{F71Nn&T?{GX;7~3AZw~7dkZDRUW984Y~#tNQZ$&bjELx|!c zRl7asmhLIOTz&J{C4o<;#T7cu#*uvG;dHn!vo(7jCwZ2_>vLhO0WabATxPQe>Qfhq zZtXqaexF>|zd1ZLMOnBJ$xRc`C^d@dvRE@s5=oK~S+^>isk4wEG)hX7(HK2OeXY85 z-_I*!HJ$!@@q;P97iEUU$8~mZb_Z>jMn;JbTzMH-RYTyb!!Eg(9RotjyiyeEj4mFo zq`zM;>FGv}YQS_qs=o1h^qpexcaHUFZh4s-rmPOp%bcatAE8)BaP#ZRt#@+D#>2K1 zWwwXYb*lJTo{Ws9lDQ$owl=HlSKoH@ut)_kf4@rpNZ9inKD#R5DOGLuyE~lVx2pE( z4SFFH`%35>!DJ~HUywoMym3Ud8ajMWY!WL)37EW7N~s;@)_~KeV7V8YO=Ed?xGtoP zhtRHt(vp3Qh+8R7`(j6H+elJ_dw+j zCWa189lUeuqSW2ZZTD!SI7FnhNBw3J>NvDb^D_cJ$JLGZXdbU|S-jH~_uZ+k%PUjz zl$JoWo4mxCZ_V;~GvFoX8|FNg{Ijma_@wCd!OOl|@AbuxC*!<+Yn$a&75_?9PB#9K z=3IU}I-Jz3#o-&hM`_YTs5UdB_#Pd9igTSV?O%OK6jE3UTSS=QY;) zw9gZs`AAm^}646h53 z{bnvmC{}QecbOC?rRA|J(Yn?^7441TqEKZv8m`t4mhAf%xD?K->#gI_R5QZrAAPsX z6C<_xP(gQN7#)IVqRl{p!_k!SU`bJcQ_?@1^pm_XRh;Ax-bqq6^*75J!#Ky}?OWW; zxQd}}EDWs9c%h}4l6AOo(znGIyYF~aJ^8R^Coomi>R>^ZQR(>_S@iCq#XhS!YPxv& zKE;b+0%XL8rnY-(8imfg+fH?+pQSu2S)^P_83RTF>a-3sU(j4P;b)Teuhx3lU-3q= z;KrQ}=LHAB)paJyL@XOQi`mX-pSAU^?c-^T$9inqR%%(r_fSaF zx(?;Jh}J1_Oe@4WG26TBH8^DiTd6qqtwQQkJrmKwv&=8C=6NESR--y zVIG(7nI!OA)n5B+zTD!|<9DuhTi#h8i9R^=SV-pbc!pHX1_|k!{I)b%IvMNZpU$n~ z#&GursTzNByPXy9a!8i`I-}A?1dT^OQzhrNd%`N|mxZ*D6-6NUaz|K%sNRn)^(JO{dBYOm6@v>r6$5U$+>Br?%y_ide=pgLJOIHvb zz_3ttn2pi2C6HpQuDy%gS4HJkkR#L>xI%!M%vtth7!I@=&=w+eR|vG+u>lt|jw#F) zkI1IgQayMllX6s^gQ^BQ7Ee|CYt~NqW;1*`ggxH;3CSG)7#^1@{p77Y4}s#Fo$L4w zyLX$M31f#e5HD|kV5ytfe0Y0rX!DumyzkF>cXM_vbg{+n`ZA|I4$pHOZ&&WO?WlQX z^Q8S4e<`{0cGGjW#Uh$|ar8l1mH5RcKb7Q;P9|@{H$}2OF2=S+T@YJ)k>NUBEa_69 zh5WRsnstzlYz&TIkYW6x1N-B6YqYO?#aU?_2Bjms2^&Fef3r z0wX&GxF) zk$h8=beHOUS*tHfGObH)`Xp-Q$xHZ=d*#zNlxW&{y9xT{H14~YuOV^0&Rv^!T+N{m zEU9uC<6McCSn=4VlUvI>@uj-|^=+{;_+lmTm&a1WqNU5Sak*}SR@6Y!e_wNPaaj(4k>42*A$=YWKPLXDa6cIrGb?!y zS5RpzpNt(q$WJgohBqb895m}VHsdD3$?k6?KeojZk-y6vVNLsBCySy>04?gwK; z{_Ikv9O)dx=L<49k*>qCk6aPckCa*WO!AjR;+H#)DL8*sx;$!=*+sE2=YL>huAXSl z5XMJhg$AY)<2+P^-%qf>5adN?omO!!_3|miuL(a+JEV%biYQ<6a{lR&8vZdq>v=ZOLXZ#38DEW2ZvR{kfz&%*sI#zO`~ zehNVaYOy68MjeQE96o=kf-tHh)Kyk}`!j>gn+bVlarw(pv^*WnS6s1%H&j*qDp(Nn zUiT=zeTzZlo#*v=-pt2?ry(@m86_?ZzE%3X9~aMGfsKePf?pjSgTVXM;!8CfgWw6; zd7RS>A5oB@B1siE%qpng$km%t%i!~T_RO&E`=u`#RSnAG0rY+CFVs_<1{=e*zx44< zm$izVj{>i`8SaaMb#>%>{n6pSa%z<6Bi6qWJP7D=@^%i&g5O(S@T!9q+!xOopP09? zu~}&gS7c19OG5gp&_@`2w^)^R?Do(4zZGZub3*<_fG_Xv6fC;p*eFu;M&4KdB+h)Fx;*5abUbUgUo|Ml8s0T zm`2-j7r4f$(&ec|!^HX-F31aZhAgOQ)8}&+W<38v!q8FNPZxm$D|gnP8h#x-G~Uzo zop`KP+;}s3w8v{{=GLo;>J+C~)16oW+U|a0h5RtBx)+y3#7*K-k1MpKUmA7<*EL-f z=FTB!uGZsb8MZwckPMh8vt*Gvl$r}^J-^%*zALwL!#w_>{nt^$QQY>`|A~N8iW9+y z9B;pUT1ahM0zoYZC9c3xgf*IfbK^B5)63UvZc-ns9;l)#4IP?whBHj+j}ymZ<5WM* zcA66riv3L0XY7Ez*G#ZXI&Hnfb^~;N9ab)&D4r&}2m3-ulL1v{c#?t{@zZS0Ia}AE zC0}0#mIz1*t-zR!LfsrA^X0vHFZd3Um^TOvO8@@4I(~c6%-i@U`VIfU=lR5m?{(Q9 zwFiisqZ}w#z6B%{$yj)M7%hMER(d5iML9|w8neHv=zb#SMn7fos@~t}=i~>TBkt6q zD*>w!i=3B@_sV-3hy145Uo9dVOZ-!2%wJV?Y&6`y?zvTO=3iB&^;_{`oO$p^oT;79 z57)kB@Gh10fBr6B9ArMuq-Sfl^uMWd2Att3a4?}$L6XQM^ZUUZn{H=_7F7fjqiI?{ z{7gWa)IZeI>irefet7_V7_x2fX;JLKIsMtvm*+R5%gZaQATGj* zXB&STVPoVIW7oTW^cLQ>|D|bHT=r^OlQns*yZg0gyS2T;vyHiw9?#>}w2!qUg6=LO z_qDT5hJHdE?sSx^M=$VtkTGs)=JM$0wRSj%c7Ou6Lph{Mf)mGY#zlI~oZKpTjWfS* z?NPXa?r4!bVbyVM>+)IlUHAW)m4``sWh}=q;xu7eC_;TyU47kWRNpG=glT?zN%3`jCz|5IIN|I2cRj6xM9+H{%= zUCU{|R$JucajZEF!nSxqX%zCBmTM`c$+^N@teEk>U(;4@Wh2Fl#SLXg4 zZ?4-jZ#~K0xFEin2Y%qViYqDiL2vwrYArG(C}ZyN44;?t_19sxYuCMwT@XnbGwR$9 zj=e2Dp21;1vzS^Wad*WFVn!!?j8+iVT^|c24$vUE53 z9^wC1xZk!se$F}kx=?Ii1=Y5E6i>XQ!o_=7<}cWWAI0imu~`Bj(iMHl5%YfcND?hY z{hMz~%5mFiZe0Gt7)L2)w7i~^{r;7|+=*@ph9LdXXv*^afXeSiQ?mo3tDG^P*YJYB z582k)?mhN;%~ERdEwA|IJ3xh%G9$;gYYS_s-loQk;A8-GW4a~~?wR;} zcUfAVerD2dQ^ZzsvxB8PKV)6(-GB<68)5=%v&bt5xQXl{DaN}X)jlFM#i;{=fFap_= zGDV-&SLd=$%CF5eXnS?}mHoO1_Jg(_-K@Fn)pZcem3bH~V4?QChn3HZV8d6qw2Bpz zShFnQI($8g>MzHfHGyZ%-+y=7y0C>7NugN!IdLjNL6;e(Y+Rb=03oV2H&JQgM7!9C zVu0%050`jR4<2dU#ISTFW2$8WAm5pULsLG`6h4`^lwybzLSW~@E5$i0xebD~x*88^ z_3Whu8uKA2Kgd##eBOJ{XZAzTWhqfEAk9g|_8GFNi1o5pO*3^)PE+4U?AV`&GtcTE zb_skQR^^3ywn8>G@o4-+)@@*Dqh?%tB_e8Ii14&0JL5(m7QmqZGh_+Kh^ziw*t$W! z1c-T-d*q*R@{0|z#N{tBbd(F>3(K3G#SZT!Qj!-mHVXFl2uxi;2|8Dp7c{FT#9~;1 z6%jZQFzX0vS%z1zR=e1-PKgLh%CzAt%yHI44%r%_gLE@x?OT9kHvqH4z{qfgEbzB} zq4V+2OOmp33bOZija*zF>gHlBrY%fO3vVCDn{+JQAKf^*t?4!QmT&5P)|cC!O3?xm z10FkJ;$Dhv%PXW{a(MlhCC^O0mx*2d)Fd;0~<;deSWQ;Gruo$egjEvm9^!2B1b1FD^l+* zE_-2wajY)?`rdccGw-@P$EDd@V{boRw?7&F-I-z{ZZ{w$$#!>V=MmVrh|^g~KMSu@ zin{9W4z}htLeYpfZ$k8~d0B!%mVl-?pDG~n%#7K5WRcoKoXDFwXmgT zI7?VyJcBNDVq(WXo`>-e_C|f``9qu2pD;*zI>~vrzLVtD`+IZ}s@llu)J_X3Cuxi0 z3NvwgmFQTMo{-Pi`{r$OALkMPHwA75J&Hx$*2%M9FRLpySXz3WBeZFng#}8@zpvBE z12%jbQXR`_{K^3>ahB42mgk6s{5P;qaJj;?XNjm-&stvn&$98vIEUf#=hw;WhZesp zC*wY7hFd&phw0`+2W-dM_^6uq{uv)Yq^$G58GQ3F_r{008279_G~b=yIwem>qn9g1 za{6OZcU{kUZ~Nt}9D9xLZFrufp416Q%ygyVyR6w=naIVQFv}kJ*KRzEd$l)b3=H2I zVtpogSnRztZI*|@(Am>%_Rm#vI?xFIx=z0`79;&##oWCy3F>gFP$4JzcGBzQu7E%C z{AccFe_k808lpcb)I?XdUVTzSgO+`xIr92mKJo-LwfD(rb^W%&p4^?H`n8hPaqIgo ziPq9A58vDXXD&Azzj2$pXJ0}8E^*-FqF;t(8 zv`zdh;SH|hy_E;(cSbf>9I9xulQe&^WM);=jOWqG`gO%~>q(sE#+5JMc}fP;h=LF6 z^?atUfQCG?>Evb7JA<)ZEc1rgtiE)v`;d$UsHqA1>VpzJKi#o*q=vGe<{eFY83ghf z`S2BsupJeCJ{iu>_%3{p5IdN)$jU zct6s?5e)(7Aqz*@^m!p^xQ3R}jbXbm-4{uy6Gi%Rnola?1}?ubwvqw7J5N~+T>4J< zh7RPsK4jE-W^8ook1TUuc_b|CHB^3}zjSiY;GtylxW_U7Ys;FZXSGb|OzB!c?;@z^ z;IMrKgkuTDWB7U51Os`)$xVS5+3Xl&fpOak5C;s-n%H>t|9(S3qd5M6<$x&Ed zke6bz{29mny(|BH^Y2&XlL&Vq7P;1GnC?A_Iil=vSHyJ~bG1GA6UWBf{HUK`1RM`3 z2~m}IG~%Ay8QU=sGsyyyDuY1cphIT3TVK$>d1lV z-X>k7@;;)NdnrS1rAFt8&qk8!rbE#_ueMCA$FVAMbS^8P*)CrEwQqeHrjf%du{{=k zKrw|VyzS*{r)PKND=Q?Rx8KowZm4W1WRq9_yg;|Y88e=7w{S#z66%-Ux~~G{ZEcs< z)}3nf*2c2jx45!6vHzEn{$VKlTX%QB381QWUhS-fdo{IWNI@ZgDy38t{5aB7hv-vy zL5)YqX{HT*`qwE!JZBvNx)pAMn~3$micGyF5F3$AYtx#Ghv>+06(UmUukoYL3aE67 zKRvxp8~2mcuvRfASkqe^8zN_5_jI0l0;!p z@6J9E2zlpF94elFo_ftD8p?hT&*{Zg(GZJx>=i0-*ceUFbY6&MVpfOhiRD=Gp;xn9 z%!irW7z!Mq@iXe6j~qfN?1=)!cDG*I+Ssjeng5CrFnsF;iEU|bKdUbQSEgg0%D&m58@j#l8?j_!mEf;*2-^jI~b5>-0QRMCMFKox6fP?@N3ktRRic zRm33FtpRtV&>oR3aB3+kIvy8CUjas`MW7)Ie1$be8H_uxi=!3_f2pg$o%J#5T4(Ww z*f~F!4uv<8yF>U=KF&iie~&A4Qhuwgg=Jcq^dem&_I@!GAvIBfkvMI6#{ zzWq%}&)3#5Gz-8FvlaMI`Gxv||6D*yfHr{?FBByotLEOKEw4(P2c^Q z3uy?+e|7LpfgandSvpjZ=c_R{#aoT5_r#4W<=phkkIlh}JX02Y9~*zS^^)TSimz%K znIN*wor5{De08)el&0FAHV)!nxjivDnEJ?NZT-OwAoBm`2$@kvp8)z~f(x|wSN&Dv zc$hYD=S>JDU=I0&4Om=ZhgOtSl&YwEXNrU3F+UZY0?*x&=f}1;*uD3UYe0-LlYUdl zjo(ORj9XnVF?Q9O4WRsF!cD7SXH+I|kGMUu3bfx}h*d0I41~8@PL{(w!RJ|D_b!yt zJb9rov|Gn(e4JPHsU++NjXkcvReiXpA~o%M8F~Ah%ZCm4b2Fa$<-ZI^D@+OhPj!9T z#Dm+PvmtvOa6)ttPpKW^Hi?r4bAV9_gbNGB-gFg>3Lg;hKV!747Zjo)0{v90ifTL| zR0STuft-9{F_zNZv&vMIZ$A)Au7JlT}Cu$c|KW$I=2APkoYizLOkuF z@D5Ivaws^Xe|b2%D7Tz=auwehzV^lbEjWl46V$3lYfqKcU7Rfac2P2*(tD>Q{p(NW zS5>HtAPS!^Z>Ea`k2Od0rkejR!Sv7P9?2ccEA02N1jF2Dm54aW$sz@t;oY$`#_nGG%!U;`{aE-}Qp?-LS9tPEMKI?r1Rhd(txp(z{D==H7j6q$M{ za%bq0NOLdrp-!y_IIdXXR2_byA(hoP(iPa#+^Dr)$0B6JeKjv^JG z!mZ(-I$3Q|PwFTJ#+QWBLeLg82t;vD3=&Z8TBVp_(kD(sxBrtiFOpBg)j#+jE6vj*Mp4^4;?Nq+lw=GldSk>iEG*W_JUtSe9;a*Vkc9xl%v%DRuaWm;M>RIyWbzAUH&eYFGGiVf%g9yW1(4Hzs_ruT!)6 z1CfZ^3BN6SBsK|$cXEfy>;=ZXu0FZB9Aj3M*z{uM-tA_NPT7N^%&e@&tXsPhGkJbY zT8g>@#GThJGs69Ozv^%CZ-2UW(^rDw7qM;Tfkb*^9@)6^M*1^E>Ra-QlDl*Z4uLG1-b_t-vObWUWEV6nZe>AoU1CwDjh^}1N^U|{{crLy+{gs|4;-VfltoYN z9cQ@*tS*6Ih=Onc=8O8jXFh#n1N*4JhLTHGEYoLF-qU$WAg&wF>;Q(3yF(8n3K~Td z*&S$q=BlTwT#$JH9xV|3sBUSt>^x}xQ>$G-uE|wEaS6-=_!Y8 z7AckYIu1I62PbOxmArRrXMWH4&2Su+Y--y{X|gCK(c9*y*06L|ldQ+;R_ZjeceBST<{?Cic3ntE4d-YoTUi%GA4H=clsmE(`2=eo*d~Z8bPb6onAL-K%b2%k3A%s_k&Z`ZVb;h|ce2a~* z@DIJNx6Ei(_1m2<&M_1fQq4nlSv( zWq$7`GdtY(diAB?=LhvZMvoypVlsg40Z{7ksLe4f8uw=(#!o<^fgkpHfXbLx678vo zUpOvEczvQSE&{2@d^0Xnj%7?c8{2A~r2RAn^DA^kAPCR2lrywJR0?<9m)F%ZpZd*o z>e>laODUpek=wGDv0KC89#>_Ove_ROO!}fJvRh7&-Yebv(zRK_5x^r7P*)k6*BjSFmG(+mEAW z?S~`%n#A;|1V37MZDw0iQT>_|nbK>mQQ@xN9>+#*Sk_wMkNUw)~hu+|JOLB#Z_p$&GG z%GG!1dU9%iV*Q!i+XO9G)D)h684dK6ELRU8w`vSQz3-&t;vthsM z#v-3@9S~U5ZMB(>jD{wcq}HdFyrDrokRf0ZkfNOBT@fkoS%O~}@CPmKq)hi3J@A(2Y_+XO(hPr}7 zp7idm5^?0-6YOr9*_Ax9bo(Y_kx3~nE)T+Ja!=66tnmua$he*}m!b(L8o&?V$Apov z5fx0nBn9MhI|?qQ6e3yn@TcgYkqt2?0DFfVz+bcg03nz>1Bhi;`4kw5avA=i)@{_R zk!5mm+_`DeFD)=|og30b;e3@;NXxiXd$K&4!10S{24e@JAzD^9%x&(`c##3Ji;cL; zzI!Omn)*_j`MVt_+~EYMY?A=a{wGQY$tSse2F@!65ShTBz!=H@AmeC=!g1Y#5(JoBv_MpRwToLEb-pKrrBpmdbVB?piFFx1DedKk=~9w&+^(T}1+9 zk=1&M0PcHM;lC{-8f3oUykT6P6HyOVbk1!$-WWxN83MpbAn|Me3c!g7GKN2Q5Jk;4 zu!c|3ikF1Hzsj}N{H;trF9wu;xC>WNQV~)ko-&-JWdgYJfKzMDVzAHPH{4M0kyQJ0 zj`{k>c^Y>#SPw_dOVMKlAI2^V7^^1VHrdj<3Cc0Z6ua11Q!o#rrCG!09z>miT?5oz z5HNlms|Ts=F|hP6K|vT-+~D**n~1m1p2VAIyqS6nx!x0o2sePW!Z~kQd9GdFQl0`n zPcSSf22jO)Dc_MS-cz11+@!@3uKzDb4~>0x?c4=i5xPput)1;h&4S`88)QpVp_Shv ze;n=17HH38pEgMFjh{Gc#FH!U!i7AB@NfLUSot4Lt3Hmnw4tD&M!o! zvr4-b;Z#Nf_OH_*U4wZ0uf9Wy)}I5tPUbY}G9ABcFOk>E>EWT?_MOWkmHlDTAnBJz zLBdTKiM^)csDulCNMh~yhX-J+8yAdllKS^*(3FQP#43Z2%-i^D&C0bzRL#6cjy^eC zm&))XrJNK41E%2>6e*vDD{vj^US3f#jKWlKL#T3`nEv4~7&(K+v;pXKLTZo2f6{5- zgtRljEaCWin@E|ik~I9PA_oREUGy84{Fwb4BeCF0)c@Bjp=Rxblbg?>892(wFU4v7 z;e`3GGQ#kg2Z;>^-h9MSU;%Sd-U5=K*^%wT3(dv7TPllBwGieE3QU8ZXf(s?SWE@+{|`w|d8r!j4S@JamZXcuW*wyvB)Q=Y z+JrIVns2OufDEeX{IwLQ0lXZVqj6j>k^IXd!QcVzb*Fv(idBN?_%=^f?Rb4Z!kh7$ zHbl?;?y<0_y*Malp14u8!*wRW-J09+4Qu$b2ayfr-uAyzvQOq!2aY5rW)s{dNwG%8 zjH^!*8DAvqc2LgRjG>D6_9Dvspld znXCa{;<3u(ILYU#`!H+_$b#Zs*q_D!t8EZ9M=HXm_Dn3fjSJ1tHG%(zPma_tu9xE~ zxS6}yzi~jb1NfelCh-T!W4vOX(iix|evz@N&7Zx!O1Ku`kxOwDg42Qi9Kq#}Y!Wb= z1q#hQC$>4(n!8H5v}FS7MS!elS(DoOSrczcQKQQ679pwG++CM()4c2{d*sx>uqPM# zFIxkknH`)OP}wHCPseZBiGWK%8Nj}$vND|_L3pkr6Y}UfZ|MCeIsb^Di#_chi-1H> zp$h@}Gp>)TpuyOjOw! zo*!?sI8YIgnynL?x@^S<4Y2$hfB@Zhad$9kGDkC9X*o*^iM>jnP3=BV$_Y|$dooTB zg@FD}{qy+TdQ`F1Ixe+tfi+b0K{k#s__LUU!IR9?3F{hjQxB z0|Nc8T>~4(#SJk`34yPizM%dQIk?!W*NyVT}qjn31!&J64*)n*SbJ| zb>-Uq6^Rl($?}SsCvUkWrt*t<(qG^gyG_O{kl)ew8_nR5l6Eq?L7KFE^-kOON6o97?GKV0I1RP!jJ-iZ-u8X|?2gD<#BABW8s!hE%zPJ4 zt^SE=E}X~&<6@Vvbif%YGTH71Lqixr%}4Oj5)~KLkht3MRMtdiHc5@$Uq{+t z9dhkRRC^h}p`v3@-p#Fx{FuG}iVAWB{n;t48F}( z>Upezr%LgkklIEyNIgylaIxg<4WWI>Y|YCnRGy2k z|1xiNG&@y@sR+Q`u3{8;H>kqd=@nI^S!9iUB$Za>DR#iK*4%5EG`e+*9=~GcGOSUL zGw}@UE*e`U9uhZCNA!7x8>__HWo)f_fy7=DGlX(}PDDo_~o$;f!a@pdWN6n_)yF*jn6OvMr8WIKS zAIj(7cO|t5@8#rz^44sS1#2yoZT+~#|JFq{LsP|D4LIqcfMkKVzO6a_4&qN?i- z*{yhjd8}M`;L_KKC7^JoHEs%upX8D^W4x!Zt;8h=h4P4HzEg`F;9FN6EmPe~bW#o$ z_I=Ux9H3z0PWh@xK7*PKSg+p#)#I4JJZhQu)MCi`)NRQbd)Q4EzG@^(E!$B{ioEw% z05~>GD;Al6OmIL4#{5zx1@dE8cMSGDIOuGMj;RP7PRFAy_^QnUmIuzsHL<*HL71xjIgd@*qe4bWq-h(hj=O~C(w4Bx<2yddpHq$GPy02#tS8VZ1`Z52q z`%^XIviGnfD|TEztqTR4>vrPqAAt`_gWjYD?I%jgHs>!NS(6&P4YdJ83vTRE%9fDB zFS#um13VPqv@8*DyAUmNe`s+!gff6W`V#R)!zk!2kO0L0kAV8D(Sj$quFIp>urM6B|!#bYC+@=+Gps`J4b-dH$6K8D|Z$x-G5rm3F=k#Bmb1()5Ev6?gFPr z&cAgE^wOoCOF)&vSC4s(TO9G9#X%v)7z8!YGHt*PHVA&vB#@P+qgo&bmo}%jr$0!p z9lvnoa}1#L!V2t3KyMv|h(Zv$le6XR)@{R$2qmOTIR1K(LLC~g&K0&xBQo4YV8Ep7*jw?PxU{mJF;(F|3m-L z>v*(TC5si0T6D>q8sxprvyP&+@gi68Z#l+8#l>ByxY!@tC9VYkfrGQ=KUzpBL1G4S zoy%dTqnG)cl&8^Y0;ei@tjJID8Vs-ihaEVwj1)REt_(Y;_kBWiT4)d8f`iO(?4R)`YEcIoGI4$ZSVJxQQUZgu=VX4cmBV{m4zDZn- zi|u<@lS^+#76ElemXdxJ^zXapO|~~%)2b|Y;5k9pUJJhd`RmbPtjDOr=Bt@b?he-{ z_P@iD&fYRme*U$R=AnO&ipa3;IJTw6WTTpkuAVp2AS1uvzK+i$8tuhhaYS(Il_+Av z8pe%BkD~*U6bas9l{p5_1`DWzjU*Y@Zdb*hik?(IWhdC z^JZ`{?n*a@?G|ax(>XWi)nLjycGK#<*wk;(lKawCs?PJ4AMQ>j9%@Ejw+(mgTaHL- zwlup%?mFZ`&VK*5)Tb}XahV?bEaKm5zs1PBUqE~w=s6c?`XiG7(Cr|(%{J&#;F`>g z)=PSpfBoqNwI3+`8`(NRFZs5rzQ-TA392Qrc<>?`0X9YbSV1ey;!flD5_@ zZQBh^yq1-SG@UMBb*2W^Y>tBV=Tlu{76fkCDqL?BRe4GMI7G?7zyJ>CzvCUbxh!u8r9FQ zKEnLJ$rXGhhLMmVbC-C@JH;^~LRXk|KEo)c|88#io5zM^R{FP{6`$xAz^Ia&c zEP#D|X4BriZ;@hX;giSZXn$S!C7(cg>8JB0;Xj^i2vx7VBfvh&p-7v$)m2d?($5lg zXFaQQO+TMR9hPUXQGl&X4AC7uDJwaMSfYI5D=R}E{*Wp#@7bd*{^g3q`wQz1Jk$1q z_?r$V7QB8P6!9-l`P9^ZPD7HunXh5|Jy9~4lheA`CLnO6?$D)-ch^ks{rmaNJ0qhK^zj*elyVMDHfZ(H=HRP$rcfu= zyAF5*b{16`UvuDXp>l6~Xv05>n7?9w7`pi_4v}=*N#Cih<}#{F7yhxx;^m3*RQiPW z;km1EF5jKVWa#0^JD1Y-Z?fH;_|k+hWDKc!Bj+YdKIkx$bMf*1;w6-pg5!UDnd>?u zZu52@M5IuhUpuz!<$N62Wcp1W(yqPX(&HxpI3_`jzqNlxES;itW6B+;D$V7A(I=o+fmkoYc zmn3PEt1Kg!{M}eHMBO*bDmJYy$yonXB&B}r!6{^*%&%Fj(ni!pq!&`1K>{37^!(=M zGs`*xsda!-wlb{5bl3a1VVc!>SuX*ZbW6xX{A+}OnK&hIUQZIhQM;M1lFYw_u8d9* zHqT4Rmu+WsrS9O@>A=d!NH95z2_fl_m8sbq*qhZc>F92eorgc}!i_aff-mB&$}^d6GX0!s5_;(UAkKS9%%V84*7)m-cRWjU}pPvX~Pcj=D0e;-cl`D_7y zw%fY7iryV|X}ixd+NGm)>!aW9ub}CfWothOEb+FwY-GQ?G;ec|<~KV2L2z^c+m(XX zpTl43t-KB5% z(@|bhDsk@?DS3C7dmaS=pL`4<`QsfR&;u|xr%9064>_-AeDbCm(e>^1_olyDK<=2A z&wfekB|1tvBD>&%MLBAA(NVi3@13KzV|PGx($6$Hq@p_7S?Xo(LvN-zE%<>#oLRe? zC5Hhj+%Z8H3bNJH+!8gt+CxT%&j8S5Z2BcS_{4JX`fwm`T*!9ac<7f=xB2}Ev6q1o zngxs;71Qd|`)9t-j&|szB-Z7BIBcc!|N!G7}Y5BH{|1kVJo$4*L00b-FTW{ib^L zW-ea9;#3ghhyurgM|{$)^GMNqGM_GJT~`0tvWZdnjrQ_i*iiNUJauCI+bI5Y_Xj1d z=@|hnx3){`r^+<~;ZUUgV^+teEEkZ84|u4BDm*-nXG?kA(q2+CCiGb%Sww zlrj#DvThTn<`!j}82`<<6yF#-aAo+*#p# z?m%+({j|_dG;Kf({k+qt>p1~nldf7Z7fh5}evx|QGq{`?F%k+KE$kiXi>QB^uC{y* z%VCg5V3C!#dwv6@2k(0B&CR82Q%tEV6X5==c}Gq1SytVMV)gs?V_WtTlZP6@*RFGE zqga;V1r`SS9h#Tjd)_?p(V-S2B}VGxgyf`NaQ_THWuNxs+hX74hdhx@D7vO>KUo?j z2?bSl&C#w)vyCTt&BeaD4KVm?sN8Axw(YDEB^eC;s$Prs`u$@Te|jIO*r9BUD6nwt zcM-GB_Mv53W_7Pz^VGV9ozEdp+wB^d>-8#2Ra!fcH3w;hBQCF{3f&n!!gb-46k_vV z>D@8ns{nsQPdJH1B;JtnOF@+*`OM4>tnQ0ql4~ZWh%SpExNx)TPyGUuxi=4AJq=g~ zXP#`HCQ1-_gijav5T9;04qta&qGcyg16H;>s!?DWy4+>*G>+PY*WTEa*FFdQKAIbL zR-z?fT{ZTO8CAjv)=D#+*2BCc^v9M-gHUS3^uE)9EIA{_hB0m+c{*E$ipx0WlbJBv z&LjIR*+V5FTXK<{HIem&5BlM8YR2LGJ9mejYQt`|^GS~F-e(laQxMV2y`qo3xPkBg zd-SDhLeP4Nu?p5rhOr&XwzP4eOvL|VKQOg<)iK}Vxy4KMgnqQWhl?+EYIzOwYk4Nu zX%t?$A<4oO>VGDof2?vlT?6Q`tNc=AEl<;k~j)o-{sp?*cb#pHtJNl z>6^}x5_1hrAdS&$#J7S)v@$AQm+K5_O?Qv&MxfPSefo}I;M8`wuNG%m+~}hkO=kDCdyPUE=l#O5PMvJx8}(W}p+Bh|4W1pCzvGkiV7%mcgZh^3=)Me3 z)!`S&^LqWBECdSB7JM zdEYkRuEeuzZ<5ImLp*pHCdHoXPQbrgd2{*j3GjObrC|iEVPCOu0|7NO`q0(vluTdD z@RU!efe?eV8d{G==D9(PQLeHh_QN`_0FwA+jKHqQJ?GI;?$P>4E$>w>B@t_eu3=eq zo!dsciqwNyUoW4DeYdj5V-i%Kt~+}eR-04vO`{!=^0{$=_m=hm-Ob%jytR=2g^Qib zLPp{vZ%9C`LeaU;+%kKrEVa?=NsY++U%zdqD+l7m19&97@LGNiuX0A;Jg~Zwr?^jC zxlJ>@KRkG1$S5nkmiLzPVJ>euj{@?FXXQ8bPMvv)&u~yk1T!_yT6U=I%UWz#CC++y z?A8S;1)RL(Q^~93$Yb*+0CA=~^at|WTAI$1#?;*VYyEuQUxqo5pj2R23qA)!IjJ5y zqGNdAU;IWDx}oATwCCPLgq&PPIT6V4DVt8Pka4+ieC0QXy-sH+Q(ISjauziwGNdKn zZo)pIBiw9Kodr*iR{@vraFJ!Zf5)58WqrNklST4RGp6T=^TqUUa~)+`a3=aa)MK5| zrFY)ak;iCq|JKf|21PeV&JWb?l~1}fwLyxzhrYH41Lk418e$0l<$ds+hbjBQOvvAF zqR7_PBGGEW)$Tr9rk{*lHm~2=`fcs&f2L=3)p*lXSF%1Q_SUZmbS`hzm3WWf%v30# zdk^n*2VR*GXq(vzCGU39m=@S#d$U0D!S68e0N6A~A0d9W8%A_dud`j!x`*zj49Mv`nVfwfmje<#dl`$EAL&Plo;a4O`r%GmF6EH+ zaxXtXdc?n)YLG|oo(p~FDNs-+{VQi*3usELHkQ8Hu|nYOl)Xox&tcYmb+k^(XCE4p zw3O_z>QxNhEn6sInnQ1ktN1EQYg znM=iY?0T|$IJLk01hg>FxQvh=AWZ&2OM=wLf?e$%ysHxM2W)=;O(@#2h%qEgFDA

IbQ0iV0}mM_6x-XJ^#~Q!T(TLtxQK=;2OPB5*Pj{5itMaB@N^pSRBW5M zm%5g=_2I_Q&bK3t*QEzF<{vCD6q|8^JvawR8FWJU?iIT9g%x0!1L6;a3N5L7e!W2! zm;}p!mO+IHyBfk=jE&tmrpHAP{T4Onr zGlPK?xYjo}Dv%P7&b~`@@6t;7Y?Cu9u$AKvl8Wg{w|W(lIqdJkMHK?{ZeQNy-QBC^ zkeO>dM;|bc+~$oNM$LX&9MnU+c2t=YYmSYn>LjwhExN8@s>ERkOf%6a?u$ zK-3>s9Q^7}Avpn$iCbGw)Sd3P8M;j94Ey4~_)HAdx-=6I)`#9mZ)GZ!06I<(hhmx*uFK0K3nyl5Tl_s zMmC4+30-BbBe(g)_J-dsy(Mj#ozDvR_yWyMB8j;5?N^oaSR?Pw_TKyr7P(Nb+$PhF(nm<>|GMz};4r+uh5DjJzi)cP;NhS^f>l4)~}f zkyFkNpUg9}XRcHxZ?2yXgkL@sLSz()ZT$W#}>^4+G zUBm*5pEA=hC&MNLx*I&xq^&B4%(>XTIIU z%G#(Psw7`Y?s2D}d0tG9l0}X?C^~=kymZ8dh#`cZD`Ti-q-F2+r_t%t-tAXSTwr8+ z8LMg=grKf=^ToSaeTw8|jVgz(Z_pf6+CFwG^l#a7Ue z)a=#ceX2f5aFj>A{7Gvw$NT;;GV;PQ8jexBu{rxP zXl4i$NGhQcJqd>t5=IXT?RclH%MwzAY}2&HOK| z7w#0jN26_gTPUTy9EtIl*{DwV9eksVitCc&r!0yi4Mp#O0FNmb-!;v9T=VSFf!3yj z^g7)1dOu%=$gKOp;1vP$pB*amXEQ{cIu4S~UEWod;U@#7>|a{_->T&}i%y3>aS^>_ z%wwjm)KZ?4jY^hFW=G;W$h}Tx#me%z7On;eGcg~bBQ;<)609>6dNZB=!GzzIkQ*j@ zrZyT><>z0d4yT@9y?tk#&ucCdw!> z6`}0=g!rZI<^#b78<mNX#M<^=Yt;0KV7UpYM78wSpOzv>FMkC)p4GH zh|WSXi~C8qHF~}OUz#k{sft{KXSEK;I7f;`EFJZTyQ+x?tv(&jE)@klLGnTEx9P)2 z!;4deVi#V4G_ZWuJEHQO$2pDJ%_>+)FcP}*m3 z3>{6<%j^E%2nMZAsD1SsgjJ-gT#^xLcaG(j>UJ`Bo~#SwS6%^ViB4bM6d)a)Dc=g} zybuA22((ZuMY>(jbfVdy$UT2HkJ#MRQ`|amTc~}Q>9$Al`F| zXax}ygU!MN?IOLK?1)*6!#ax+_nzJs#zpS&^Sj_%R;St3R7}X(ej3J@6{{VG#zcdB z;F8cD_aioYf}zGM`T3u`0(=Wi5_@L?u3zWU{MEHXKZv-_Muu_eR(32j{&4PVuaO^> z(8)r6=wnY7NFuiv8_l7LQ<##?XV}P5qq@<9Ci|zxH4Z2s1JeGIIY>Cbw#Ff7B1b~x z>ht%c6?6-&Q!Wa$MJ~IrJOOD6X%CVmIeWr+ofB5<=q$np8V|UP51c|u=Q1YA@cXKI z#g)jq#&<>)C(w)r0jYI(xR;thltKyIc&l4rBI9--j;8sQ72G1Ox*TYcYjDZ&W7>3v zx185kb9ARu$b;ujPu5O+60sr5k^RD83#rjLqAusP(ThH?#qs!$JNVO8!C=_} zLCYK05@4k3N-t9C$a}d?&&A&s=`qKx93NvMFY_!0-W4h$8kL)G8P_;wR*RACzw#B- z`u4$54&WhLbdJu9Z+Uf2i9Df%BL8ptmL;cAwSb-3jiu`_{(c{U9HplkG3Fu+Y* z^&*aXpGV#O<_bnvonI~_bq0s&Tl(vlm9t`ckd6lo`Rqg={W9@&-=rRw-ck5hZ8e4Q z&$s6~2QLST+!@<-VkAWxbF}+0yMI#6ro8veuxD|RU2P=5oHwaZWPH*@f=DzKf1Qcw z;{Z$;|C;FV{5}z=ymJ^m+fkDvLy|q^yS9#!g^Pr2IcK+U`%omOvh0!2=F4W8#cI{W z$mQxT;2XW6O$tV&ppX!%{_Yup-ONa}$W{NKPf1iBxlmKk9G0Gbftc!1C`Y-Ics7ra z^wk-LBEu?I@EymD7YVJe{Wx2GO=&H3wXYDpNAl7Kof@$D_LuZQ0|R8kK=8)6 zcgjxk7x$$w_gq_7zGnW08|f`ZRfqyX)b3NX8UPe4C$_u z>0<8l_0uhrC#X`S$;Kj zp#Tq-4lU5v;z($rTHb^&JbSeH)F`r_Z()Wwo<%hVv}3h42Zp9N6BS|?x?+NDFmZZ& zz^NVglp&W4dZu+a=?4Rc2b#=kbowZ2@6(sGJWQyM+{v6=f@?aibl^T;;A(OIxry3y zgL_3(LU-fokJC}PMLD7l)j6*9P>By)d3mGVv-J-+KkP|c)aYMvwAW0(Yi|1Ja$k^a1D-y=swX}{9W$Uo#GWN?5a5dds|dKzT2>%F+JV2lLSmvpiYeIaF{w&G2ng^EVMZ7QV}BsG+Bm=7kR}|A z<0TptAAgaQ*6_-ZM@gx``rSf6I{w@_QAn$X=JuPxi9-7j#(RIlM!1Lsj1$9uxLTuK$Y>t!KM?r|+A#*tO z<0ZmPPMpFFg`yMxxBcu8@vTY`^Fgz8~ohDTj*}aC1uZTG?5aX(Y``>2LX`o z$=Ou^?Sm=|m@>%V)ovhFjm|f9kA`S7Ff03eI0b^m96e4ZJ+sB~af<#nvA*lr6y4)U zt`(LH-acXPHbK}a1!@FePZOp{(@quti5Fp>UdqSI1LRJ;39gKttqGL`rWT*4BnX93 z6nRC$c`C0Ol;ecYha>2SDuiFbHNm3*1&o?0gThHQn^siPA=C_x4!Zvf9cw1>9V-gM z(W#}h`sA`Js;@qVSQ0RizGdb1F!s==)U@Lb5Rl@$w&GXQ_WeZa`}ZDTuF1(zCmqk2 zFXNg}ZA!lBnV6$Htg`+!hI6!1Sv3gP@-t$?i`BiE<3X%o^lv|!_fv{)F)egr>L{nn zpD-NzrYZNz2tSnpXwnf%3U2%|k|k~0Q;nbG{5ZQHRUZJ>Lzig*qc49WWB|UeYaO7P zycIWf-{5hTk@3?YCW#-XN|1`GWjK(wPSEeMeBjq#BvDQHRZ2nplreW59IC_>PfnPE zcq&V+g9l*=udZhd>96}uhBtjP_Ql-lFY-mn|E^*fO*wY6cBNbP73Vn3kN z5a8}#nVcLX(rXtZOzMnu(%DcO z07QvFDu5ZMdbp=E^|j^|222VMC+>Pm7_~mb#^_yDSxC}U$K1YQ*kZ@15MZR~sKnkx zYo%r(ziRv;pZ?7=ms_Y5@dYppx%hBnJ9Exd^-8+%Odd4_9VL7e zEjH{NCNmF*FcfmvetJ@(6|m?Nc2J!w3Gn}P3OWyC876ol8>WQ6Ye!A*MgcJkhn_q# z2{6{g4=fc@KHvzFvTrump;O`?O&MqKniVy?B%S6_OKmvq7V}ZJtCvp6yICmiw2FgZ z-sQ8CGLK^W32xkE)>5-;uHNQM)Iy&OsEhFlL%)s)QY-$S7Et_fSqsui7-|0I&M_@6LFT zf)Ns7@1_mCwM_|r!jjl5J^Jxer=x>L6Txf{aGcJ^F6a*o55l4T$teBA@a)IocE?SiB$O z968YbkfLjqdvY$wh-Na5?0G2(NeIB!mA!PU`dFlu_IO^+}r4Vjc} zZQ%hNZLB`&)pL8{f+s>?8n6I(*GKTI2nc!#;?4i?h9F{fo%w075GG?Wu4jlK%fox6 z)pvu+HvSsz+=P`Nl^l!lIH6k@39S`;f;tJVr%h6lpyox#-L|FI)AZhtlI1Gr1q9;F zS8Nrzgbtw;B}?uMqAS~y@-vF%f~HV_ornQ65%n$?O9tjTQH5bbE9&WlMOx`i*W&JY zoZpKPJn>wL771|P$L0mG?hp7HGPTpHs6sFyQDYIaTFJst%JNFP7v9BJ$-e9$$RB$f zX?GG9fKBM|qO1St28g9Go;sb>5-y@EmzHnf7A4@RcDdD1uvomgu#(5g4nYZHv%a`) zOO-Pounx0Rs7<8kPDjnw7io^$5h`ExAPnng27Vjfwe%nD78=1KxoX(5RYd^uiqZHZ=)N;#H7#9I%=K3a>1Q)=Aau}(AcWfZIb9~Xn7i3#V zDEju!k_^-77G0$mHtkfB;ym~l6-TNU1zF9}Bn3#8Hrl>cvfW2<@RNu~Uhp42Q95QUuSW0wkVmR6ixTpk?f>tFaCT zgu#sgs`?=avSyEytpzpBlF!j9IbU>4!)xDS4FgZKk^f@>e>m_TGLl=r`l}FPmVDYo z9!D2HNX`#u9`~_Lc~W*-+pN*TUXZ%ws~>wWGC$VekA=Zg>|L8?1}Ye4{1nX1m(uO< zm#Qc?KtT@-#DLpavm5iZ%TVdiDPdubZIiD{>GSSM{}X@zaTkLr|F{Wr*9$Y29Bt$3 zdvW=u^(};)@$wi|FPNE!TZDioS9a5DU~54^NhDqpo6Qfg5zcp}JQ?}bIFrc|!&_)SnZ<W((Tc#Se5H+ zakk(Wlt&4bkx{qF`<;;2>(LRfZ=I@SB(W#V)V!fIS}#b3HgexEGB7AryvyxFWQrbz79?ry<*T`k6ME6aVMkaqb)PLC<~w23W+%dkG4Ua|kA{sc^Ts4B)HL zrjs+P0bErX_hyT(AL|u6zV!99MuZ>j>{XAFSOZ4>0Pg>pFS><;xrPEi3jIuL+f?^B z&h?9XDT1Hb;=n)@1Otaq{(s`fc|T~`(BgqOT&xz7KCiO>5O8_QUYp8M#zUM(h%~bCu|P*aAahHr@XnCqaHf$j-N_~Rd(cA@c1pH{ucQSIAob2KeEDdHFcWDJ=0 z2s2x6=~ra_Hf3c2?o6>t#N9HZNNHn7lwt3a!B@(RKVwOSSvb1loA2=+edk{Bgrhd= z>)Zj{5=E?^$)-rhMXOYFl3O!<<_2&Pz0@^ts@-n|FUL@8Jay++)3+=bi>ofy2mmL# z6uN64GsnsjvhY9jK?)EJcMxqCCscBk0 z`9H3*3s3OdCM1_~p3#+4Ia(%{=jfKt-Fd`#N}H;=0;aPhe%CZn@H4(`;wb6Y8<#)? zy(X5a`Gx>tEBziKt$%-B)Q4eCUwiDT!+gO3cChYNOLaW67Ow0&9t#7i`p=wBdbORy z3+K;F6LABvGN)>=wV?OCybIwnR z>@jSOJABbL!~3;Ll->MRk^B2q)>qK5krk0=b-V9xmqThZOod=epep?35hm z#VIGjjUDdLHhVyZ^l-A^S*lK5w!9IQz49!eVS(?5S`q!{@=ua|rWvSp|CyS7DNw>( zfe)e(oI3`McHxQ$FguA$BlN}E*cBPyPcZcHyJRe{@)~_Cz^0`2eOyQ+C!~fyW!QvI z=PJZFNIs4ZonqQc%D4M5b=I(vN|CL`A$VO2#6i5IY%>b!&9ru$davB?P&C{%1Dne?&PkMKNTBr(tA6-CM$D15$Ry%;+=d|NhaX>e9TQRfdYZ{Cd9VJ=~QR%9Linf zv?o_J|HF95DIWbCxkdwc*AFO3ggO&F2?K104Yxs{HkI)s_;yu;Qio03>_n2568?8S zlWNRjS|_2*#r14bwvZ*)$w`+li1gTH zPtktO{HOGsF|LAEAq^r?M_w8F|M>1L_DA&}Qx>4=lN2S%B)m2;T95r2_2q_{0fJK~ zLX1fI4vHecj%gisab3qFgZCjOPt?_Tj{~WrP?B)d>-4K;$J$sny@xH{wehi@@Olce0#@8ng9sf{CtAdi$Hsjv8N{G*qD~Vr&BCs|B5rh7QT_9)dsTJB$(C>Pv zOBK?5<3ZdDPx{SfVM{h0XeH)L;j@+e5#7k{RR(Ct?Hu z`vFJ5|3lz7OiTrMb|VlGq#wW?=ie!$x0zgi5VwrXU*RYi$6p}4ThwRG8C_S()Tzm+ zPs15SrbxtNhkv=**D@}jZ9kqyipzIgl{0*?O#Ol;QJ&p#Un;Mf5x9YcXp=|a`HImU zp7=|xPEgvxGsW%}yF|*Qsg%;XtXKY}NfaCA3_ZgT`~a0WN-F=QM{uK&^>K9Ds%+0m zOkt@r{UtJFcK#%fhh*F(FG=EYSy<++k~q2nswpof;fZsG2=Vmm7Kv9@xDO(~d(ovd zEe$Y6nvkWwe_@%F{iIa6bwXP;#sev5Agp%u!}2P%)FxMl=V#fd|D*7^#?J!ca~qcE z+okdWd=H=Ww^iuf+9tK(J(84#+aE^=j0QKk2hR36;oV$S$=#MG1bZytMbL?0fuZz* z%VZy(iSKNHmeQ#!GQu=>|^3@+UY-F2py8RWkE2HC#!10t-c?f3&SlnD^xEhatdJsMFn_ zv9D<#L@&h!+;gxhNiI_)Eu64c4P#jqy3Xf<{4s&3O?8qc)0ot%jcXqu`EKt}5_7MV zRhhTX-Mf+8lEB8E)2KnHlEHlCL;^H$`r4^j;|V@gUpxWS)RDVnRu?70+R%+ z0wY`Z3L8sR%0=C3Ynv)o8%<*p9j#}5&;LP+nNlYeVdTG0enUx9VnozREl0)5EWD4#uislcVRU z8}cx}&gPG)b#VEJJ0iN6kRe-ghoSOftCa6_HxCb4N+Lhl({M)1dNM6FPyK(Sy#-X1 zU)MK`3M!z0gmg)RfYLP}-42aNDGd_RIFusYjUWu&0@Bim($XLeN`rI^F~oZY{m1=0 z_xiqft(Orl=bCFy?7h!#$Jyr`H;mLYEK>Rn8TRw9w@yQ;w~0hQBi+bL=1oN+a(4*f z>-A5kH~G7Ly>=(<9`gR-*5jKLatLG z*?3p1!wT_OtOKXJcUPL)>y;hx(D3JRl!ABI+qeRx?kT zpF4v>9GUmc&&ewg)2WX%uPI9c^UyAhwHu5WO&t&bBY8ONY{r|)GZ^p4O;Auu8n-U-uDb=$%tynNc1w~HjFd;L)*iL z_yH#WoF2s+$_Esl1DFFZW%{&i=&5AbqwiO`-F$Hm2+&h7HvV=P{vE7A9Zd~ltpJa0 z0zB^s?#pC-q(aD;)L;<>QYhdl7yO9}-pp5Cc@rgob%{c9IsOTLR1$qY zcf5r6hoG>BckAXKQG}?!6fOSR^XUezF_yts-6N8rZ842`Xhk);;Ekp^caLz_ovZL> z&m-dEudf8|+%P7#4s!m;75|9k9wgKJy_SEXX+`>GMaPi8i)Te3NpfDp2{lwNUS#2BlGX4UO=2mNG_hT73nE?`%jJ!0glXo5+bg{Zfnl z(_5+UXFK}m%F zGYN!sOU7L4ic^I)INl!yyRn?C#RR&A{X(&{>TIZtG>fn zC>ILszf?pP+`WSx4QmLt&wKPw6|4d%R7W|Um)hx4#mcKeLz|y}!r=sFoE7#CDb?5U zF$~H6E3`zYjp=|7J()%&fL=nEKPociUy0h25H&2GUe0l#{E@z@z7@l^ zUx3DHk5SzFg(y#o2U~vab@~|P@^h|6soT-RTt|3^Kb6*fp05PTK~dTk>;=W9>J#=7 z;w7n8BKV1j4$tbwA5#-$WywInEZjd+FVXbQpP!DA6VE^N2tijy_GifpP|ts4ti6{d z652BUjCF#;ir1Ce-jPOrDjEK{80Gbw{4D-!CG$9^l)}#* z2;Cb#`NQ&+TH_n1*iAH@U!b2TUeI1P3AJ$nYCiZ6ZLRG8G}pO}Y>Z&}`90CrtDte$ zhqlp+zup(|v{8e1@BkRM9@jC1k=3c+B zc~1PBpIHoCU1eDbClpI-=N{+Pv8i2=2veM%4yhB)8crd@UuemY|GwnDTQ9qm?6mye zR7d{sIOQTYa%wuoL=d^2NLd?Vkl9K|V;(UfZ3uFjVqq%SR#Gy9fGjf5DEh8^18ho% z7KW7%-7=YtUq;iP0MA8io6c&$^5(==hfAKrVnLo!O2teNJcqh-XM-Q+^ElV3A@1G# zQ8Y@gF5Z=?!nQOvTm9EC++*z9Zbo!#hfnUT?fih|?WNhT>>~~{mjWteuJe;;Cl7y^ zq@Z+`fjSwCCa8FQ#v%N5xVfvll&(H89h9{0jm2eo&lw?vM>z_k5o&5DUshswZFSCB$=6s(9GlK!(oI4Z{p=XTZrPoh`uO+oizt*7E!19)rV>|kxc*PzS1 z9~O_Fqg9h^7X2MX7B4^Jm|VDS5x=Ptr@Lmcy`rBtJO4|yo8wDVii6ViJPGr`YdjGW z3rBeA7*52Ll8i-3R4;|r`nTv}4L?r%Uk{t`KcyB%HXV|l@C$ADxT_x2pLEcNt-DI; zIt@6h_x~6WRz1(#;9Kw)3Pk7gE(>_*C8|4DugVUyl%mlCl)Z|6N< zpKCSw!zZQVY#p`%VH;32-+vTWxIhzwZbUsv2i*!UZg6KPi)ez}MYwKX2)hVJBF9G> zOHI6~_H&{x*RO-DNREGH`;>!ak-yij(Q97iPQ+Sv!FE%OF->q8>CmcY1Ih67PEuENT=6 zg|5e|Pt3fTq85)_pA~RN*EJNv-mzU8&zW|*`7gA?VQnh3ew{%>P#%AdoLUpEnbM*YI;6uy{Dg5e(RhsH zd`i(`C=M>|;c7+xMMK>#f`Peu$)MvX;}?;p%(6c6URgqk{8?!^-P2|9dDW3*vW_Df zMCqD{1%(1aZUbUay>Y@-wpWPi#W&!LouP7%{+(zAIt8+~0|T?9>8!-3SMR{y-yOK_ z5X~szJtP8qOOl4Z(h#GRivQ`n}6JB4X9v?jIaKm?xsy_AE zV4iNbB`+Jwee8VbsNkOa#*pSPKrZWWwr;QZ)fKQH{!S-YAux1_k^oHpl>!N5D=<*b zzfih;pw)>jEWLA|8>3S`iMc4Vb^l6O+OK@T&_)ues#2y@|OZXzxn^S z;3R^cNQ22pAWooP`AWzk!Ql|99DWOqGwC}H(bmGAQ1w+J*t-)|cOn0^D49M&kojGU zf1`}4f^kc#X|g?DbNe~w$ul#&o(mygt)if`=s{)&{Ey+H>67_Hi_ymk1y9*=4`3!l z4iWG~zR$_$smRDX3H1}o0K56pmB=ABh#p*IDW;4b!peomA!QJ5Kc1R*7H$y|`f1(W zjXXB7$(|4CSgBoZdqBzr=7gxsHnPO7eIU6kbxah&~1W9%%CIHDH@<$EX zMEgJ4ci=O%I7IIE;keE8Ql6m3%#DRC72jYBqN4Oe3%Y~cUMI2**%7drg-o9{4Z!xa z8Od|0MMK#1+0~X<9Urs1{{5VVbQXJ6WiEGRRRz@I%LA-u?n=)VV`Z`^N~~n>WUrhj zghY9=jG1oJXBj5|H4VfMNFm?szGZbAE%$?UpJjVtwzhbk|IYukO{31 zHoK3T5!d89uy*^-!bO?Hxpao=g4-_KVQR$AgM>?GJ&UiJW{bdjV|~$WPL|-SNAgAh zkpSG5R6X?6a9EB>p}NtDa96bSECfS*;VWMD6GQhsM^nMZ@r(Og#-pxBPc`x#h)l|! z1b9)?A!8_hl_ni(-V}UzYWIThmDq&KoRi19PXfO6oYKw*`hFcI4TW2J;q|lDM~K4* z4n{}L&gjRf!dve7AM_bi7h;XQp$)0*!iWn(6m0zgE1>_rQT+?GF40yFLn}2r8!;R~ zl|gJFLZo&_xucBixz{G5|i2u){Acsq8hU| z7U;tozV`PO(seZcxOl0B2icQnd5Vy{Daeu9hn*2%$R^(HeT%NW6@GWkGh=^sV@sAX zMBi~V0cA8Xe>dhu?5UYREvvtLPnEv2;Jsgw+wXO(NHU&T<)V(hv9zM|k&@EWj5D^V zsVPpisr@_cR{PpUzIer4?t>F2TfFg@p|c1$qS|3_4i7drjc)>-u4L*K=J>2aIK8X) zFc^}$A%UbExSROFq#cIjUiVyYd`B&%=zWt8sq{pTO!{25Z?#);rFAFUqT@Y-X~UcI zpJO(&MAD5j%vKKQTsobN@=MFAWf33GZeDd?$0vm}UC@P6VEJWsT&%2m^?rbBQ~#U1 zCU-C1TcCiAS_a&T*9HOf;aEc#-=u|Kb9<*2+wl97$lTT8SoLb5&ru^9&6 zQo_C$u-^0z@nW75ve7sBx!uq=6sY*i-JXDv$qUnZMh4+d1;Cazz`gfd8AY+JdI}|b z-P?*WCm(n?9A7(V!{alPmA}tWl%wXrWx!IDYiNOiVR^48v(G|cTKRZ5j3dKk*e5*m zZ9e8mMptZSZnYxLhV+fWo#7;*L0+E7&8(mMBA#;G77S<7!a%%xG~@^vdmfczNv_O; zwV-pK)b__F8CI$;?q)vW{Ic}n7A;7Eg5-bi%MJ#J8ih2O{FTZf^Ux6M?)sy!Lt#?h ziDh3xr~cBE{^v~k#}ONjPsn4FbRB?+PUl{0k3j~}Pxz|y*3D3Dn6}-}$B4470oO82 z%~A2G6NS&Ntc_$RIi#VyNk`XJDoPSzgDFN3dZyy1K_yH<6Olyac3q)|U2rRjIP%Ob zY&aCoFQ)r_nlsjv$F5 zlkGzq%GA5vkwiGiG<^t9bCZQ4%_O^fzg#NPOE3VI7D`(Gm#oV4W#uUbs9>*2oLQh_ ztSDm*aGk_esl+CGN2OG}IZva`i@ZB{E9nvSz|$l-HVeMn**8{gYvXLw-VDF59f)(n zbWVTlM63U3Bky*Ka#21;%IaW7ay&9mtXcLv@te6b`_w}IRx$R1`&r#lkm<2`B5j|{ z+=j^Tc_YqE)pI-BDSWUdnbJ5U>X2QP$bP>f-zf~P9`7G{_%f$nv1jG@Jd`H*prm<$ zfi|}Pwz@nC#QT&xw97Eo?obAbT+#|SPo)8SNd2WTE|h~(GdMZ39sMq>Vm%t^GEV4~S-ry{w%M|vFCmQmS5M&I)gB76FqMUz z=fv^E&16J5F&$(foVYe51x@f>^nShRfD0wm59}RtDgfhZADrBixqR@=E7@$JRiw3Lrz2ZM%vCi?xHFg+#dEXl$$-B)PI6rh6^WRjeNzxHuFBz4BC+tJjoMRlRypZ(6lxiDg}c7C_L_NKx@Yr!RPydL?c zSWX!pjMvi)&ggVbp6LZ?~oL;gbC8reQWmWIPK6ILG#4Y@ouTA@$>3VM~LAN@bb{W?umG8ig z?C?ShlvFKi$_<)zFiriuZqMRPE9!o=4mnoi{Q?-*DnI*vdVhm>=(2g=&V(+ZtA3a? zz6i6OMM6ye@~Y0AW`D0P{|%?UQ7s8tsx}}mAX~x#49-C?q=8kJDOq#F; z50z*v>|Ui*3YtA60(TQN&IO11OJa{aFB0*^HV;;eSshri&^O&B+Rv8ah~X72)!OQ6!*GLY=*n%X2JBa23dO`5jUI=xz=?R9B1Ji?bxJ5RQ(dt9rRm;G0-+}G zpa}QIGz)`(b_}=SMO%!R@UN%NJ~T&6C+ArBgtI%5X@9BWPj<`61JhVB zE8$(YG(Ee4W7CL)RBw529ZH}$disdywo1qZxL)^u+7|ztrI+5r?`;t-RplS=?H`@V zQnz|gWan*jZb$yNybaq zy)*VtOC&oCy1u}7EjiC0JXgh=KDB!R>gNIXkUX%Iq|67pxpY5~2@NGv?unwOj7-n|1JC4lHqpXCxwl2K*Mzk@?=f=4!&Q=*{eU^o7VyBO_>1;S)}bjc?lJwvHxc?;tuOo-Jle{69J` z(pd#-I!qqAM}KM{(Uwm91`|2r9(2rUpzlpn)m2@ht~>Ri>@e_BXz%r64)#=H?V5B) z?5baG3^$AiR@cubY}TRL@`v?gkn-2SrUCjF^5+imkX~(!ZBF`dw9-|uqx}9YPwBq? zdBR_6(l=CMbE3yHlZGapxErK%V|GxHk{jyB1Lb^)6+rpG6&Z_iqTKiEQKQ}l z9CPTbc?3A66Z|v(j{3Xt%w}>XECy0@ActuMu0Z@{U;1ZbD%AHN>p_6UV1Q)ZgCJ=;f}?<>_f z`k8H4?*W})s1Zk!*$%OXm1jbGBGtR zeB};Tf8H22>$c0;MOC+e7p1LI5KnzljOAEWg)6acZ;o?^L6f|ovfZm_T@!0B2VIZi z%&wBmNflwN@NRZ){gH3m zojJezG65@piJV|;p-ss#tMBo*Ufa1O^0;Y{&*^#)*-bUtZ{{vBzUhvS)p6uWgph=$ zCAv4&ol8{RV?(ZHGNFN$g(mwTq4o0$sTis;{-G%0K)YhGuD>a`b+=^9(b73ndnsl8 z0HOCZ<;TGupL+;|_*&ZIc`B&`^W-A++5>qmD(YAkFn9b_VMb7ohWU;I)RuX@` zl1yX|UGuoydH;oCpK4v)H55C{?}2R8Opt3S*}6gsq~ZbWDqvpsWKBI~o?2#pQu!|y zqP^@*M2`MhL0i!$1x*jGc|ME~TsO^eJkrA_W=(bpAzX=?Qg5~1#zEA+Q7sV7j!WD5 z_nWVK1$Tb9_tYh^;5!8}E*QDK{)HA<;zai8si4NA+$)8{Cj?$9_TIzhxmAd<63y=7 zp+5~W`qLmFuKzR$B~2Y&y{gjzcA76DkTTh8x6_rA`4ZX1)*&MWlS+$`_YipLUIe&W zE>?(mQBBF*Fw>AjZ)sjzVF|%3IdN59UMEDp)x3NYvvA$;?Ubg1nmV|ebJD&B4vP{0 zB1zpkmT8G&!S()?!v=N!ne2iQ+ae0Jtfw1VR%`yk8vF5-`D8*Hhwbc5YH=Dic@%(j zBoG21*q7`TmFc5-2m`VPZlex`e&qFBbL7P^RpovfzsCMXvhuUVK9hm&h2>4Jr_L+Y zN~X&TEX3r52_u?kOjH?K6zAz>>K|DESE*LFjt#~!Cjz;RyRQ{EAL_84V`tP1NO7A+ z=<0axFR#rmN3Td?Al=s|bIwv?MyCsss;D#dzNwUZ$?_U~uCbc7pUqntA5TtMaiRVd zeqk^!I8m)$cOZMVbQTvvy2iVe+s4r(G5(7h60*zmSlAGG=G^XCD8nHF9r-XTU$gMf z$OS{z>H(@xfE~X@*>^j>vHOR!)#_)vd?~xD=38!hm0NXB;xz3F^pcv*6zcNEZS@`) zosV0cuvhM^;Ii1B;l}4%2Z6DvQ877pMz})jyxI zYY{Kd39x4^Nzwi3uo_09jBm zqca)!4VV?!h5Bt*(b8lZa0*TbhNz_4UTE4kl^QRjqrHBF_WGpS#p$r&h7lSX4J4aM z4vH2D2qFhv#T+C+%L1c(P#tz20I+Qp6YceWESv^%`I(6et@lD|a6q^{nI7%O|cQ5omOsCwcZqx_#fQ%r2^&@$@dW zRaomtDN1jRI=9xZ)T=V3jH_2p&*pD*?k$AiuB8;@%U?tn%Yu4PLJ9OLI=D)K@}-~y z1mKDXs>OpyL)QpEb5X6?CxnRq*QaAn{`ENc+JAXEOZ0yip0@z8cZmH&6Q6NwZEB3F zZeBg})|%Zs_ni5>dnQ;dhn4|Imyx@I39f;FphvK}lIpi${o(8X(#p$f*Ksd9B6Zoy z8FF_cLl5N-5nOqxL3DF{Ml4upG_YX!Ehy^am;z7;s!MlJ?e$HucUcd1-YMF-rh0w1 zVP{%(E^{YB^|G`NxR*`8&Hz{jS`&2HFbXQ_2(IU2^=_{|gm5k8jgeto(yA>8unXpc zdSsbg;SWVc@t50oc9?b~cji@Dp9Iond@y>UN6|!Ln)5h}>*w;^HuDV=+4VJR1{cjL zipmlz!S90z*u{5;F@rvZZ$A-Ns_qADIG(@fZAL)BO0(le5*K&!`GLJ(#$!$PqwQd) zg}3j_kP?KK6p#Wvl7=w(tggT_yGoOm({-`(wHdaJ$|mM}?u0X!vh)UX`T0Fr zvwj%QsvA0?T}iUn=t;YFW;k`|_i@@~t9Jb9&8_1nCtFW~e$5qTv}Z~;jKyov00xtAOOXmB}z4BD3j=VPB8U+rt0!TAGFG_YRGOL|`Us|lC#_b<@&J^F4~`@03wv&Wp7>PvUg>Nn0( zMTL+N@Q}$FE}?9ke`tb&;&&~h=SLWsTke)v`<0xcWeHkr6UUCLDT*wHz>MK@Gp%07p<4K|KRt(i%jPH!vXMxzYE9t4U7L- zECIFtOCpxr5Mz|7WTqeXQzomLN zNHIg)$4FI{GBIL0C?C2!M2i1+11Osh1-xCpQ7S%>bX$<;)t)H#U(RRLznq zL-}PkHaMj&%o{fmUiGaw^<@(=&0<__#)5~PQ#O4P#%ard1bX2 z>5!daxMK#Xqus5_v%UGljKpmXo|H4ESl*kL;tLEDltTNX*TChsnR4uZ^oF_6O)(a0 zhM-+)yyQQ$0f3nQt_^N2jLu(Eop}iq;7h4`?yf5}i~z1ft8y=btIE4GH`d_*!68<5 z7ZDc1b@wNFH^ZuOg)=tRgDu=ossX^C3kYnv6CA*gkpR@c=QV&Cm!^hI&n5;?N_bVS zcE$|i#{7?|bG6~gbCn9nG=+`%sMO?8i0YR9p&WQmIAnLxa+C?QL7%M7+e>NtqrCss z$4lslIcy_UWwZ_~3FGpsZc~fJOlUWX#U!8Sod1>i4IC*Y8#_j5E}hsSao@R$L@|zC zW~1*a-&WGj*_PU7E}PgAFn=n*;zj4uzAUZNik$bJ?_%aY=oMh_diXdT z8gUivfx31puti3gORilGmjA$hzINJDl5C%ionGdY2BtOr5&t8(`@YL41M}D$v3W%< zng{pG(P-6%L70uZ*+URz;hQv{MELbq**J!7H|SqTQVMapTd~zKo*cJ2KH2&{s!x8b z1>6K4$L;`4UE(*HX8LLzjI?yQ5^>*gG&S{^3W9Un@>+I9Sy==n1-~YJ5{Qe_&g`Nh zFD|H4RwIIjYhjo|G$qsu93Eb`-@#h~m;yxbzdQ2FY6%bT|90jq}>6{^C3{cx8zGw6O0~L;1~P^~Z1EwrXCBm3&>cTQJfrj~uDjr`Fb8vn#xCbh+(1(sE{~ z@&yh_x4z|kQ^mlZ*tF!L$HlDTnbP_>D;$+P?bDE|iTM0B zdk#=@Wo# z?rY?e>HU=ErbmPd<@`lg;5hmWaK8kr4N1XG6=JUYChi@(c*MNTfuzL1E3G_O@n_ci zR;b%`T{s{hNuQD3yK=V?Q;3XskG$kudIaGnQ{&>Jtj%5Rq2hP;BQVcAb8P~*nLLaLpia^_d zf)8MA4=$+~@yAt1tFFFgZ*R4`JDT^*jCgBu1{pD%P2tg#(%D7jV3aUKX>a8k=eg)a z`bkdkC^9;}@GkXf*@T|AI)=B4i`DyIws{2{^Kox+6KgcBM)IlifAn#9i0XQ;9u|D8 zk8s#d|5#uB)O*#nAajO$CsWA=}ger}6M|jF& zywa^WjJToW`jelPtwg4VuX#xtY|E`nW?L8z5k{Wqc%9aw2*#xS z6^wbdk6wH0N!qE{3FFaw{u-Nd_G^rrnx)*D0kdn3U^Hl$*=9RjU>Gm)7K|kpd|BqM zGZhx()vdYk$^SK*?~__^_RSn2$Kd`U5&P}YkyPcg*=3Dw^~zM;>0BGPY6nm&h@F*y z4YELtPvo+8p3Cq8kZ8FcW)1S`<2$(Wp*|uBJAErA+i|h@ce5_o%oOMj9ZD1b@?7zdwU-bXvoUqtm6Tq6&#|VdWlUwRbo>FqL!$pV`1#JbRXG zK=++BAaWJVJf6;GS(a>Xer)kByb$|RGb*N%Ff%q0l`yOAMJ0yx>gJixL{^E48O zFz#QJ{221HsniwcQ4F0YMX&2+kiK=iabz4(gbIL6RvjL^4?RJep8FLmC~I@htXnT0 z4m&0%TC+m(MDicMCssYK%*M{;P-tcsj(HF#W7(1Kmc#BuN&2?S$0vi3Cl#x4uic?T zezWXD%<;l;6Anjm4bPS8W%_iiZS`^^i<#chFpu`WFiFmMAJ*pLQ^IeAj~F)M&W!GZ zc%DyTs?U;%R&L#m<@?a)MEA^4O4xWN@K7k*uFERV}0c2#8{*>a(wIaYx4|U$QMuICav!S7=FtN zDJ2P{oLZ*uK7cDBa0m4PUdxJnM-Q&|?H;B#m31{Lq&L}MYpZ+pY*cR^`_`0L+gLQR zyfL|N`jrA=s%HM6u_GTD?TpFHqL+Q#5Qp7E=Qd}VAj#AsvZu;vVW5z`+%!qAtgs9s~I6Nf(Cn^JAN-_P0xhwWD6| zZc|=%LV^T>`FuYV1X^{lGtCiSR!FaaJD_(GH=pm*FN|#ENbbr1;AHohyuI^d)<$2z zM8*yUY^;Fj3ck6>O~KZ^y_>esQNxDcFABp+rU+1w zJcqtqW!1@<@Ahx)7a2!XwR`(KrWf4bHcorxQ1K))1pEELVVVcWcUyUh_bV(v?+@j! z_whAiw6f$4b~Jg9r;#LOF2_|jVW!AAoU#y0?&Sp?xW7_~j=yh8NBfNtc0M`dry$9d zd`?j_9yl2Jp7!0|cufN2CV0Fz`%v^4?DS-&PJo3{ECwb*C40WJra6%*HMX!!8d# ze4(g?Q#R_i{+$EYH$Z~5_t3Qcu#H%YRDpYoKjAj0$qsC zYF}an4NjcDob+<@x0_8vXB{4a7v2bJP%bS!!Ag486X;+n<(jW8-jP zQ%&=ye&0EzPhZ@x8{J+HuV42BM|3<$hP*oYLZ#y4+$r6c`X0#|7B(5(IO!SJhDfHj ze%SnW_vw3bLSM%ZU)AFLTa=6s`(G$Od*^;{Xz~#3L)OHLshRXd1Y={qa!P~tTj>`x z()x>R7^=|Y_njX-impC!7*Jp5r@ekq3J1uM%ZV6?SqUVywqSLkDkCZm0K zw_r(87?0Ku1N^}vQK#58-&gjZ>L$~{=xwrDXG>Q%efD_`y#n`pMHbk_jrL(451+MS z3kr9-TF^DFENCu4STyZ#I-x-1a+vuJ#BhNSI_jkckER&c0u9Hjj1&2MJWAP}>~fzUe=+{}Ma6L3N1+^`9Ygf4z}D=F4$DSGD`p-S4KX6t zzb8!G;Mj%i|Dts}pZk6=@j5({mxY#>4Zj_X_`1Da}^Y1Ds8QR8eDJ8Q z2)jqu{h)5O|2LNaiNMh80<*BFmpth|7!@_YCOqr6XtmT59S&de3#yF>7telZEPr(_ z{fs#?_mibN{#v?n&TLnvA^)x>Ss@=IZG>Z$bYFf5zKZ4W`kDmQh;;}YBGaBW7#Xy2 z;z*y$680u$9uV?$#d3>3%yZEUgEegGYx7cNwir3)zhN`$H#~&GV?paK*(L+U7wl~~ zrL}OZWx&Q$eu@{6LDk}W%toL>MJdv%J?o?N%AldswfQT_y1+Nr{SN}M@WsY}+_pL-!kD>*w)QZ78(loQaHmjM!@1kk8}UXE)hB^X6}U86M}s{l0y( z#^LNa7@X%#ztVez_3+C>6}OSf(b=LdTm~n1JNIbfTry&~pXsI4e*iQF44-U0`7p)c~_DZ9- z9-1mQVLr5I^b0(8G@qd!Uv^j2^aDlZY7jjsmciknF0>3GP|+c%A4|KjNwb@G)}qek z!Y{JT^6$~L2Mkc|s}Epi)S>V@V5a}KBt5ocS|~CE%1(aNHO$lA-^}utIMs0Vwx*Ga_A(*%x%s8&;zQ~KFhB2#CV zR4=XiybAvNQ}-fUjta3iO~@MWbOQNsffK?f=`MFbQ@tl@`n}c{{I7l9sGwXIe--XK ztl%8{ymh)luSdjfx?wSmK>o2H5@zA}p}^H16sx(q(DK7&;iB6$$3wSk+4cuLN%E5v z)u44^edK*WDZf#X+cq40!@pL=k)_z@4kKHO;-s1OjvnpjsSWOEE+)E}0*w)ly<>cv zW5D!;*HqbvT-u;<%X)Ftjn$131!~KhhxDFq7nb6Qy*n=Tp%|+?(I%E$yY_`?8qz^G&nj+JWe} zfZOMfUX0HW>%ObYb~mu-?2;4}Ycnfq9LMLv1l>mUJ#9bhf4si3Evl~4rz_xed0}!r zHJ|}59e@j_kDEuj>?}=T+92cEbg6*+zW7Jv1gCC&yn^%U@rT^|#%5F>AH1lnJc!S9 zz37ULlf^M8<91bMpT6JtOoR=W{Pd^RO_2q1%g(MB480<|P{rcxItChNW>jQ^84`n` z09Aph{rxhdcImoX11->nc|EbBCw!IY6bYIec``__GU({b(9@bYn*)>Am>o01^zr(# ztTWgo0PAx$EJv?%F1slMoiyEf%36eNO>|@zoTy|8NvQ(p6zb6>4f{yJf zVkW;Q+345@8|3ml=8cbJNdwVqH1H>z3H4%z6uurLh=m6}kFD1=U_b15D9D~}E%?e0 zJxC4a5_#AihtIkehOeNM+dBv;vmJyy*JoITj%ZFSkJZULqz0EVo#hXTAhOyA zHA&pR_uX%UpU-}RD%!8U3W(hscfd#A*8SjQTRf-uIv`Zv6qDhj+p;5j93-BZ4iyV#M4ak+NowIKEAfSn*L*o1S@h zl(4t$&K9f9d*Y3n&BFMJ+UttU)XWeT)a#r?7}c*kQu?BNHP7NbTkjrtmS z61#Bm>4#RfcWX1~9FvFmijUB1a3JhA?2g~GhD5BzbC!=z8DR!CzX+c{Jnx-b)^}dE zJ)O#oe|@vwK;&$DmVIPmqN5tNC+4|wR0;0-hwB>eY;8=H!>crYVbFM;?vrv2;iH<1 z$|F;O`3!QuLJepoB89$%pRcVWBj4%ldc4w#D(Pa!FUYE7*yD^k$LHu`%EB9$&BhxN z1J{6Tym9_4yrBdXqm;3tJmtWzI@Uu^X>gUodUz%cI9bh*vIkFC2tT%yr_JG17&N}f z{7UU!ws(%fB89ML`MQ5Y-gbR9&MExN6~#CvzjvaXejRh?jJ2~04x_cya^KgW-fkt_A0~|-?>ax;%dfyyOM+(rsclDF!+89&Fx)2 zOw$f|MU$Sv=#OUdC+fV4-`n9a3+IGO5T?+SQpcjg4_V%xpT1}B9X5zx-S$>C^a@*? zGKM~ho}_QT=xYr764(k#WkpYfILvqn4kJqa)49fvlt zF&j4ZKFvS8gzmHqkDm+id(>q|hlby$ED<66v+v3ge2SjNAq;65^-?p=2gK})eJKgK zaDu~&0WRm&#rTN{nBpVp+o=_uWfx0ZPlHR`7VCYQ*~;mFTI90reXb~n*48U(BIvNp zdB0V=-oZfpM|<;|_f6)c4=u|XP#P1J*oDGq^Ic|$IBF=yTEyB9-lyfg4gj~{v5fp< zFb9pceT(yv?31MrOvH{@p}_PYKRIbI@)~Pf=2xN%4`D(+XGf|Cv$68LrbiEZud2 z#p1JOZu!uY`sIr)sKAQ?6-bOLAKt#sBfI^WQQbSk?(=t#urAkKyzK3kFH#mqA4x~E zE^*s_Z?W!S^}H=UGs+JcrJhU`tDp1WXQ!=|4!{Go1m(5OQ{INU! zL@!vObuap1!|%qZD@)zJu8Nh-j=IkZ92kAs34}knE(>1<#TgXbc--^4(fC_LJZPAj z!2mof0+XX6-LTu%LI7l*z>|F26QWc!nL0+vu!hb*TKIJLL0~{JFnGH9xvX Date: Thu, 2 Nov 2023 12:07:49 -0400 Subject: [PATCH 09/48] Update docs/transpile/index.mdx --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index e91df258ea9..9a05c40c0a9 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -11,7 +11,7 @@ Transpilation is the process of rewriting a given input circuit to match the top A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler allows one to begin approaching utility scale work while keeping noise manageable. -This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in st using the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-runtime-compilation) +This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-runtime-compilation) From 883b67f17fbe49321cf65b2e700ace5f93169fdc Mon Sep 17 00:00:00 2001 From: kaelynj Date: Thu, 2 Nov 2023 17:02:57 -0400 Subject: [PATCH 10/48] Initial draft of preset passmanagers --- docs/transpile/passmanagers.ipynb | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 61ae3670224..e5374a8502b 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -138,7 +138,22 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "## Routing Stage\n", + "\n", + "In order to implement a 2-qubit gate between qubits that are not directly connected on a quantum device, one or more swap gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each swap gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of swap gates needed to map a circuit onto a given device is an important step in the whole transpilation process.\n", + "\n", + "However this may come as no surprise that there's no free lunch here and that finding the optimal swap mapping is hard. In fact it is what is known as an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To get around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal swap mapping. It's also important to point out here that this is slightly different from the `SabreLayout` method in the previous stage (though they use the same underlying SABRE routing algorithm). By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit.transpiler.passes.SabreLayout). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimization Stage\n", + "\n", + "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effect that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ." + ] } ], "metadata": { From 133672649ac0af8ddccf4097c0d3acc3f8ab62b2 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 12:03:26 -0400 Subject: [PATCH 11/48] Updated passmanagers page --- docs/transpile/passmanagers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index e5374a8502b..5c986de8df7 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -152,7 +152,7 @@ "source": [ "## Optimization Stage\n", "\n", - "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effect that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ." + "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ." ] } ], From 203d673ffb0524b5753b6f096128dd496e10dcd9 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 12:10:06 -0400 Subject: [PATCH 12/48] Add cusotm passmanagers notebook --- docs/transpile/customized-passmanagers.ipynb | 143 +++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 docs/transpile/customized-passmanagers.ipynb diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb new file mode 100644 index 00000000000..7311511dba5 --- /dev/null +++ b/docs/transpile/customized-passmanagers.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transpiler Stages & the PassManager\n", + "\n", + "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of passes which can include things like transforming the operations in your quantum circuit into single and two qubit gates, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise.\n", + "\n", + "In the document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object. However, it is important to first introduce the internal represenation of quantum circuits in Qiskit, the *Directed Acyclic Graph* or **DAG**. Before you start however, you may need to install the `pydot` library and the `graphivz` library for the DAG plotting functions. Use `pip` to install `pydot` and your system's native package manager (e.g. `apt`, `brew`, `yum`, `dnf`, etc.) for `graphivz`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DAG Representation\n", + "\n", + "Before we begin diving into the preset `PassManagers`, it is important to first understand the representation of quantum circuits which are used for transpilation. In Qiskit, circuits are represented internally using a Directed Acyclic Graph (DAG). The advantage of this representation over a pure list of gates (i.e. a *netlist*) is that the flow of information between operators is explicit, making it easier to make transformation decisions. In general, a DAG is formed by *vertices* (also known as \"nodes\") and directed *edges* which connect pairs of vertices in a particular orientation. This representation is stored using `qiskit.dagcircuit.DAGCircuit` objects which are composed of invididual `DagNode` objects.\n", + "\n", + "Let's look at a simple example to understand the DAG a bit more by preparing a simple circuit which prepares a bell state and applies an $R_Z$ rotation depending on the outcome of a measurement." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", + "from qiskit.dagcircuit import DAGCircuit\n", + "import numpy as np\n", + "q = QuantumRegister(3, 'q')\n", + "c = ClassicalRegister(3, 'c')\n", + "circ = QuantumCircuit(q, c)\n", + "circ.h(q[0])\n", + "circ.cx(q[0], q[1])\n", + "circ.measure(q[0], c[0])\n", + "circ.rz(np.pi/2, q[1]).c_if(c, 2)\n", + "circ.draw(output='mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then view this circuit's DAG by using the `qiskit.tools.visualization.dag_drawer()` function. You'll notice there are three kinds of graph nodes: qubit/clbit nodes (green), operation nodes (blue), and output nodes (red). Each edge indicates data flow (or dependency) between two nodes." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Could not save to JPEG for display", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[39m=\u001b[39m RAWMODE[im\u001b[39m.\u001b[39;49mmode]\n\u001b[1;32m 640\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", + "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave(b, image_format, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m save_handler(\u001b[39mself\u001b[39;49m, fp, filename)\n\u001b[1;32m 2414\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcannot write mode \u001b[39m\u001b[39m{\u001b[39;00mim\u001b[39m.\u001b[39mmode\u001b[39m}\u001b[39;00m\u001b[39m as JPEG\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mOSError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[39m=\u001b[39m im\u001b[39m.\u001b[39mencoderinfo\n", + "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib/python3.11/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[39m=\u001b[39m get_real_method(obj, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[39mif\u001b[39;00m method \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[39mreturn\u001b[39;00m method()\n\u001b[1;32m 345\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_repr_jpeg_\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[39m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_repr_image(\u001b[39m\"\u001b[39;49m\u001b[39mJPEG\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mCould not save to \u001b[39m\u001b[39m{\u001b[39;00mimage_format\u001b[39m}\u001b[39;00m\u001b[39m for display\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[39mreturn\u001b[39;00m b\u001b[39m.\u001b[39mgetvalue()\n", + "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.converters import circuit_to_dag\n", + "from qiskit.tools.visualization import dag_drawer\n", + "dag = circuit_to_dag(circ)\n", + "dag_drawer(dag)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "description": "Overview of transpiler stages and the PassManager", + "kernelspec": { + "display_name": "qiskit-wKX2ZNlv-py3.11", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "title": "Transpiler Stages & the PassManager" + }, + "nbformat": 4, + "nbformat_minor": 2 +} From a9f60556d0943e046ab537350ea11247bb350df1 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 12:10:52 -0400 Subject: [PATCH 13/48] Removed custom passmanagers --- docs/transpile/transpiler-introduction.ipynb | 62 -------------------- 1 file changed, 62 deletions(-) delete mode 100644 docs/transpile/transpiler-introduction.ipynb diff --git a/docs/transpile/transpiler-introduction.ipynb b/docs/transpile/transpiler-introduction.ipynb deleted file mode 100644 index 7b0f4b2ed0e..00000000000 --- a/docs/transpile/transpiler-introduction.ipynb +++ /dev/null @@ -1,62 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Introduction to the Transpiler\n", - "\n", - "A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits.\n", - "\n", - "In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device.\n", - "\n", - "***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Abstraction Levels of Circuits\n", - "\n", - "- \"Virtual\" qubits\n", - "- Physical qubits selected\n", - "- Scheduled circuits\n", - "\n", - "\n", - "## What levels are needed?\n", - " - For the sampler/estimator?\n", - " - For backend.run?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "description": "Transpiler introduction notebook", - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.1" - }, - "title": "Transpiler Introduction" - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 15902911053b5cd54d7b663d6b06f0a3f9aec8a3 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 14:49:07 -0400 Subject: [PATCH 14/48] Content updates, remove extra notebook --- docs/transpile/passmanagers.ipynb | 10 ++++ docs/transpile/transpiler-introduction.ipynb | 62 -------------------- 2 files changed, 10 insertions(+), 62 deletions(-) delete mode 100644 docs/transpile/transpiler-introduction.ipynb diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 5c986de8df7..a06a34d7117 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -154,6 +154,16 @@ "\n", "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/docs/transpile/transpiler-introduction.ipynb b/docs/transpile/transpiler-introduction.ipynb deleted file mode 100644 index 7b0f4b2ed0e..00000000000 --- a/docs/transpile/transpiler-introduction.ipynb +++ /dev/null @@ -1,62 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Introduction to the Transpiler\n", - "\n", - "A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits.\n", - "\n", - "In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device.\n", - "\n", - "***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Abstraction Levels of Circuits\n", - "\n", - "- \"Virtual\" qubits\n", - "- Physical qubits selected\n", - "- Scheduled circuits\n", - "\n", - "\n", - "## What levels are needed?\n", - " - For the sampler/estimator?\n", - " - For backend.run?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "description": "Transpiler introduction notebook", - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.1" - }, - "title": "Transpiler Introduction" - }, - "nbformat": 4, - "nbformat_minor": 2 -} From f18bd3a88ea315ebc5374883a37d754d2de96c04 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 16:02:26 -0400 Subject: [PATCH 15/48] Update draft of transpiler intro --- docs/transpile/index.mdx | 28 ++++++--- docs/transpile/transpiler-introduction.ipynb | 62 -------------------- 2 files changed, 19 insertions(+), 71 deletions(-) delete mode 100644 docs/transpile/transpiler-introduction.ipynb diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 9a05c40c0a9..c3b309a434b 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -7,16 +7,13 @@ description: Introduction to the transpiler # Introduction to the transpiler -Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. +Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. This documentation covers the tooling and workflows for transpilation which are available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure runtime compilation for Qiskit runtime.](../run/configure-runtime-compilation) -A central component of Qiskit, the transpiler is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler allows one to begin approaching utility scale work while keeping noise manageable. +A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, allowing you to greatly reduce the depth and complexity of your quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by `PassManager` and `StagedPassManager` objects. The `StagedPassManager` will orchestrate the execution one or more `PassMangers` and determine the order in which they are executed, while the `PassManger` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Passes` as the individual musicians. In this way, you have the power to compose hardware efficient quantum circuits and allow you to execute utility scale work while keeping noise manageable. -This documentation covers the tooling and workflows available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure error suppression for Qiskit Runtime.](../run/configure-runtime-compilation) - - -## Default Transpilation -The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`](../api/qiskit/compiler#compilation-routines) function. This will generate one of the present `PassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. Each of these preset `PassMangers` are composed of six basic stages: +## Transpiler Stages +Qiskit utilizes a set of six fundamental stages in the prebuilt transpiler pipeline: 1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. @@ -25,8 +22,21 @@ The basic usage of the transpiler is to call the `qiskit.compiler.transpile()`]( 1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). 1. `scheduling` - This pass is for any hardware-aware optimizations that improves the efficiency of the executed microwave pulse instructions. -Each of the preset pass managers include these steps and the primary difference between them are the specific that are called at each stage, set by the `optimization_level` flag. + If you decide to customize your own transpilation workflow, we suggest using these stages as a guideline during development. + + + +## Default Transpilation +The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`](../api/qiskit/compiler#compilation-routines) function. This will generate and run one of the preset `StagedPassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. + +- `optimization_level=0`: Just maps the circuit to the backend, with no explicit optimization. +- `optimization_level=1`: Maps the circuit, but also does some lightweight optimizations by collapsing adjacent gates. +- `optimization_level=2`: Medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships. +- `optimization_level=3`: Heavy-weight optimization, which in addition to previous steps, resynthesizes two-qubit blocks of gates in the circuit. + +If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler Stages & Preset PassManagers](passmanagers.ipynb). + ## Customizing Passes -For more advanced users, one can customize their own set of `PassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling one's quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. One can prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is by looking to the default sequence of transformations: +For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is by looking to the default sequence of transformations: diff --git a/docs/transpile/transpiler-introduction.ipynb b/docs/transpile/transpiler-introduction.ipynb deleted file mode 100644 index 7b0f4b2ed0e..00000000000 --- a/docs/transpile/transpiler-introduction.ipynb +++ /dev/null @@ -1,62 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Introduction to the Transpiler\n", - "\n", - "A central component of Qiskit Terra is the transpiler, which is designed for modularity and extensibility. The goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by a **pass manager**, which schedules the passes and also allows passes to communicate with each other by providing a shared space. In this way, the transpiler opens up the door for research into aggressive optimization of quantum circuits.\n", - "\n", - "In this notebook, we look at the built-in passes, how to use the pass manager, and develop a simple custom transpiler pass. In order to do the latter, we first need to introduce the internal representation of quantum circuits in Qiskit, in the form of a Directed Acyclic Graph, or **DAG**. Then, we illustrate a simple swap mapper pass, which transforms an input circuit to be compatible with a limited-connectivity quantum device.\n", - "\n", - "***Before you start***: You may need to install the `pydot` library and the `graphviz` library for the DAG plotting routines. If you are using Anaconda Python, you can install both with the `conda` command. If you use your system's native Python interpreter, install `pydot` using the `pip` command, and install `graphviz` using your system's native package manager (e.g. `yum`, `apt`, `dnf`, `brew`, etc.)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Abstraction Levels of Circuits\n", - "\n", - "- \"Virtual\" qubits\n", - "- Physical qubits selected\n", - "- Scheduled circuits\n", - "\n", - "\n", - "## What levels are needed?\n", - " - For the sampler/estimator?\n", - " - For backend.run?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "description": "Transpiler introduction notebook", - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.1" - }, - "title": "Transpiler Introduction" - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 7c5884898da50b1f71b60c391fae0953fe8b8ea4 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 3 Nov 2023 16:11:02 -0400 Subject: [PATCH 16/48] Add 'resynthesizes' to cSpell --- cSpell.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cSpell.json b/cSpell.json index 4c0dfb7bb30..e03d76b76fa 100644 --- a/cSpell.json +++ b/cSpell.json @@ -245,7 +245,8 @@ "ITTL", "QRTE", "mathrm", - "exponentiated" + "exponentiated", + "resynthesizes" ], "ignoreRegExpList": [ // Markdown links From e78f77465e8d0604d0ba6e34850076a957ebb4cc Mon Sep 17 00:00:00 2001 From: kaelynj Date: Mon, 6 Nov 2023 09:42:33 -0500 Subject: [PATCH 17/48] Add note about default behavior of init --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index c3b309a434b..f8f21d341a7 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -15,7 +15,7 @@ A central component of Qiskit, the transpiler is designed for modularity and ext ## Transpiler Stages Qiskit utilizes a set of six fundamental stages in the prebuilt transpiler pipeline: -1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. +1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this does nothing) 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. 1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. 1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. From 5fb826b991b33bc61c3cb8a6e3965a15e0fc2274 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Mon, 6 Nov 2023 10:55:59 -0500 Subject: [PATCH 18/48] Moved stages around --- docs/transpile/passmanagers.ipynb | 88 ++++++++++++++++++------------- 1 file changed, 52 insertions(+), 36 deletions(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index a06a34d7117..a7a18a860e7 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Transpiler Stages & Preset PassManagers\n", + " # Transpiler Stages & Preset PassManagers\n", "\n", "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of different `Passes` which can include things like transforming the operations in your quantum circuit, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise. In the document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", "\n", @@ -29,7 +29,52 @@ "source": [ "## Init Stage\n", "\n", - "The first stage of the preset `PassManagers` will translate (or *unroll*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step as it allows the circuit to be executed by the backend, but will typically lead to an increase in the depth and the number of gates.\n", + "This first stage does very little by default and is primarily useful if you would want to include your own initial optimizations. Because most layout and routing algorithms are only designed to work with 1 and 2 qubit gates, this stage is also used to translate any gates that operate on more than 2 qubits into gates that only operate on 1 or 2 qubits.\n", + "\n", + "For more information about utilizing your own initial optimizations you would like to run for this stage, see the section on plugins and customizing pass managers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Layout Stage\n", + "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. In order to execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device. This mapping is stored as a `Layout` object.\n", + "\n", + "\n", + "![Qubit Mapping](../../public/images/transpile/layout-mapping.png)\n", + "\n", + "The choice of mapping is extremely important for minimizing the number of swap operations needed to map the input circuit onto the device topology ancd ensure the most well-calibrated qubits are utilized. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves 2 steps: first, trying to find a \"perfect\" layout (a layout which does not require any swap operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are 2 `Passes` typically used for this first step:\n", + "\n", + "- `TrivialLayout`: Naively maps each virtual qubit to same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", + "- `VF2Layout`: This is an `AnalysisPass` which works to select an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", + "\n", + "Then for the heuristic stage, 2 passes are used by default:\n", + "\n", + "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", + "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. More details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Routing Stage\n", + "\n", + "In order to implement a 2-qubit gate between qubits that are not directly connected on a quantum device, one or more swap gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each swap gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of swap gates needed to map a circuit onto a given device is an important step in the whole transpilation process. For efficiency, this stage typically computed alongside the Layout stage by default, but they are logically distinct from one another. The *Layout* stage selects the hardware qubits to be used and the *Routing* stage inserts the appropriate amount of swap gates in order to execute the circuits using the selected layout.\n", + "\n", + "However this may come as no surprise that there's no free lunch here and that finding the optimal swap mapping is hard. In fact it is what is known as an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To get around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal swap mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly will result in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run routing function (or the entire `StagedPassManager`) many times and select the lowest depth circuits from the distribution of outputs.\n", + "\n", + "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit.transpiler.passes.SabreLayout). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Translation Stage\n", + "\n", + "When writing a quantum circuit you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions. However, most quantum devices only natively support a handful of quantum gate and non-gate operations. This stage of the preset `PassManagers` will translate (or *unroll*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step as it allows the circuit to be executed by the backend, but will typically lead to an increase in the depth and the number of gates.\n", "\n", "There two special cases which are especially important to highlight, and illustrate a bit more clearly what this stage does:\n", "\n", @@ -38,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -55,9 +100,8 @@ "
" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -82,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -99,9 +143,8 @@ "
" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -116,34 +159,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates, and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affect by noise.\n", - "\n", - "## Layout Stage\n", - "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. In order to execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device. This mapping is stored as a `Layout` object.\n", - "\n", - "\n", - "![Qubit Mapping](../../public/images/transpile/layout-mapping.png)\n", - "\n", - "The choice of mapping is extremely important for minimizing the number of swap operations needed to map the input circuit onto the device topology ancd ensure the most well-calibrated qubits are utilized. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves 2 steps: first, trying to find a \"perfect\" layout (a layout which does not require any swap operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are 2 `Passes` typically used for this first step:\n", - "\n", - "- `TrivialLayout`: Naively maps each virtual qubit to same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", - "- `VF2Layout`: This is an `AnalysisPass` which works to select an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", - "\n", - "Then for the heuristic stage, 2 passes are used by default:\n", - "\n", - "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", - "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. More details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Routing Stage\n", - "\n", - "In order to implement a 2-qubit gate between qubits that are not directly connected on a quantum device, one or more swap gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each swap gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of swap gates needed to map a circuit onto a given device is an important step in the whole transpilation process.\n", - "\n", - "However this may come as no surprise that there's no free lunch here and that finding the optimal swap mapping is hard. In fact it is what is known as an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To get around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal swap mapping. It's also important to point out here that this is slightly different from the `SabreLayout` method in the previous stage (though they use the same underlying SABRE routing algorithm). By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit.transpiler.passes.SabreLayout). " + "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates, and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affect by noise." ] }, { From fc5bd121baa785c35fa1ef47b865dfb9a282b2e9 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Mon, 6 Nov 2023 16:16:11 -0500 Subject: [PATCH 19/48] Add transpile section blurb to the start/index page --- docs/start/index.mdx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/start/index.mdx b/docs/start/index.mdx index 60612b29441..a571f1cb7e8 100644 --- a/docs/start/index.mdx +++ b/docs/start/index.mdx @@ -26,6 +26,8 @@ Already know what you’re looking for? - [Run](../run): Run on our hardware with job configuration options such as sessions. +- [Transpile](../transpile): Compile locally to transform your circuits to be hardware-executable, with varying degrees of error awareness. + - **API reference**: Find API references for [Qiskit](/api/qiskit), [Qiskit Runtime IBM Client](/api/qiskit-ibm-runtime/runtime_service), [Qiskit IBM Runtime Rest API](/api/runtime/tags/programs), and [Qiskit IBM Provider](/api/qiskit-ibm-provider/ibm_provider) in the API reference drop-down menu above. You can also find the [Error code registry](../errors) here. ## Community From c45e44dff6e1645be6308c838f9a4f6fd67b290f Mon Sep 17 00:00:00 2001 From: Kaelyn Ferris <43348706+kaelynj@users.noreply.github.com> Date: Mon, 6 Nov 2023 16:25:49 -0500 Subject: [PATCH 20/48] Update docs/transpile/index.mdx Integrating Abby's suggestion Co-authored-by: abbycross --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index f8f21d341a7..c5eadfd8489 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -7,7 +7,7 @@ description: Introduction to the transpiler # Introduction to the transpiler -Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. This documentation covers the tooling and workflows for transpilation which are available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure runtime compilation for Qiskit runtime.](../run/configure-runtime-compilation) +Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. This documentation covers the tooling and workflows for transpilation available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure runtime compilation for Qiskit Runtime.](../run/configure-runtime-compilation) A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, allowing you to greatly reduce the depth and complexity of your quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by `PassManager` and `StagedPassManager` objects. The `StagedPassManager` will orchestrate the execution one or more `PassMangers` and determine the order in which they are executed, while the `PassManger` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Passes` as the individual musicians. In this way, you have the power to compose hardware efficient quantum circuits and allow you to execute utility scale work while keeping noise manageable. From ea4dbad1b4fc827e7439d6c64f8c9ec5b800f29c Mon Sep 17 00:00:00 2001 From: Kaelyn Ferris <43348706+kaelynj@users.noreply.github.com> Date: Mon, 6 Nov 2023 16:29:10 -0500 Subject: [PATCH 21/48] Update docs/transpile/index.mdx Committing Abby's suggestion Co-authored-by: abbycross --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index c5eadfd8489..79b4884ae11 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -34,7 +34,7 @@ The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`] - `optimization_level=2`: Medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships. - `optimization_level=3`: Heavy-weight optimization, which in addition to previous steps, resynthesizes two-qubit blocks of gates in the circuit. -If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler Stages & Preset PassManagers](passmanagers.ipynb). +If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler stages and preset PassManagers](passmanagers.ipynb). ## Customizing Passes From 372bdc9538d2109d89449a87db0d1ee98b82ef68 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Mon, 6 Nov 2023 16:40:22 -0500 Subject: [PATCH 22/48] Incorporate Abby's suggestions --- docs/transpile/index.mdx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 79b4884ae11..4898e05c85a 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -12,24 +12,24 @@ Transpilation is the process of rewriting a given input circuit to match the top A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, allowing you to greatly reduce the depth and complexity of your quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by `PassManager` and `StagedPassManager` objects. The `StagedPassManager` will orchestrate the execution one or more `PassMangers` and determine the order in which they are executed, while the `PassManger` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Passes` as the individual musicians. In this way, you have the power to compose hardware efficient quantum circuits and allow you to execute utility scale work while keeping noise manageable. -## Transpiler Stages +## Transpiler stages Qiskit utilizes a set of six fundamental stages in the prebuilt transpiler pipeline: -1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this does nothing) +1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this will just validate the circuit instructions and translate multi-qubit gates into 1 and 2 qubit gates) 1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. 1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. 1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. 1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). -1. `scheduling` - This pass is for any hardware-aware optimizations that improves the efficiency of the executed microwave pulse instructions. +1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. If you decide to customize your own transpilation workflow, we suggest using these stages as a guideline during development. -## Default Transpilation +## Default transpilation The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`](../api/qiskit/compiler#compilation-routines) function. This will generate and run one of the preset `StagedPassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. -- `optimization_level=0`: Just maps the circuit to the backend, with no explicit optimization. +- `optimization_level=0`: Maps the circuit to the backend, with no explicit optimization. - `optimization_level=1`: Maps the circuit, but also does some lightweight optimizations by collapsing adjacent gates. - `optimization_level=2`: Medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships. - `optimization_level=3`: Heavy-weight optimization, which in addition to previous steps, resynthesizes two-qubit blocks of gates in the circuit. @@ -37,6 +37,6 @@ The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`] If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler stages and preset PassManagers](passmanagers.ipynb). -## Customizing Passes +## Customizing passes For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is by looking to the default sequence of transformations: From ad57ed2aafaf708201eab9f2cb5893321570e0bd Mon Sep 17 00:00:00 2001 From: kaelynj Date: Mon, 6 Nov 2023 16:41:46 -0500 Subject: [PATCH 23/48] Incorporate Abby's suggestion --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 4898e05c85a..65c8d5877d7 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -38,5 +38,5 @@ If you'd like to read more about the preset pass managers or the transpiler stag ## Customizing passes -For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final circuit which is output. If fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is by looking to the default sequence of transformations: +For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final output circuit. In fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is to look at the default sequence of transformations. From c658982e6efee6a8de08f20383204d6d824c9804 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Mon, 6 Nov 2023 16:42:47 -0500 Subject: [PATCH 24/48] Update index.mdx --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 65c8d5877d7..8bfc56b192b 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -38,5 +38,5 @@ If you'd like to read more about the preset pass managers or the transpiler stag ## Customizing passes -For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final output circuit. In fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is to look at the default sequence of transformations. +For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final output circuit. In fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is to examine the default sequence of transformations. From 21021a3cd060550badd1861e972188633f6ffe62 Mon Sep 17 00:00:00 2001 From: abbycross Date: Wed, 8 Nov 2023 15:53:19 -0500 Subject: [PATCH 25/48] fix image path --- docs/transpile/passmanagers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index a7a18a860e7..22b1a6d0775 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -42,7 +42,7 @@ "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. In order to execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device. This mapping is stored as a `Layout` object.\n", "\n", "\n", - "![Qubit Mapping](../../public/images/transpile/layout-mapping.png)\n", + "![Qubit Mapping](/images/transpile/layout-mapping.png)\n", "\n", "The choice of mapping is extremely important for minimizing the number of swap operations needed to map the input circuit onto the device topology ancd ensure the most well-calibrated qubits are utilized. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves 2 steps: first, trying to find a \"perfect\" layout (a layout which does not require any swap operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are 2 `Passes` typically used for this first step:\n", "\n", From d4df00028d96191e75f698f76e1fbf70e0335de7 Mon Sep 17 00:00:00 2001 From: abbycross Date: Wed, 8 Nov 2023 15:55:20 -0500 Subject: [PATCH 26/48] remove file extension --- docs/transpile/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 8bfc56b192b..a38febb7ceb 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -34,7 +34,7 @@ The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`] - `optimization_level=2`: Medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships. - `optimization_level=3`: Heavy-weight optimization, which in addition to previous steps, resynthesizes two-qubit blocks of gates in the circuit. -If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler stages and preset PassManagers](passmanagers.ipynb). +If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler stages and preset PassManagers](passmanagers). ## Customizing passes From da25106c3b1251b718c3caa24ca6ebc873eb24d5 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Wed, 8 Nov 2023 18:07:20 -0500 Subject: [PATCH 27/48] Nearly finished with content --- docs/transpile/passmanagers.ipynb | 43 ++++++++++++++++++++++++++----- 1 file changed, 37 insertions(+), 6 deletions(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index a7a18a860e7..6d2f7967169 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -6,11 +6,12 @@ "source": [ " # Transpiler Stages & Preset PassManagers\n", "\n", - "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of different `Passes` which can include things like transforming the operations in your quantum circuit, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise. In the document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", + "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of different `Passes` which can include things like transforming the operations in your quantum circuit, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise. In this document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", "\n", - "There are 4 optimization levels ranging from 0 to 3, where higher optimization levels take more time and computational effort but may yield a more optimal circuit. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic based, spending more computational effort does not always result in an improvement in the quality of the output circuit.\n", "\n", - "When the `transpile()` function is called, a `StagedPassManager` object is created and then executed. This is an object which will orchestrate a series of `PassManagers` containing one or more `Passes` and separated in stages. Think of the `StagedpassManager` as the conductor of an orchestra, the `PassManagers` as the different instrument sections, and `Passes` as the individual musicians. The `StagedPassManager` specify which `PassManagers` is executed at what time. The stages of the preset passmangers are again:\n", + "When the `transpile()` function is called, a preset `StagedPassManager` object is created and then executed. There are 4 different preset pass managers ranging from very light to heavy optimization and specified by the `optimization_level` argument which can range from 0 to 3. Higher optimization levels take more time and computational effort but may yield more optimal circuits. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic based, spending more computational effort does not always result in an improvement in the quality of the output circuit. For specific details on the preset pass managers, look to the [API reference section](../api/qiskit/transpiler_preset.md).\n", + "\n", + "We'll now expand upon each stage of these preset pass managers which provide a useful framework for optimizing your quantum algorithms. Recall that these stages are:\n", "\n", "\n", "1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates.\n", @@ -168,18 +169,48 @@ "source": [ "## Optimization Stage\n", "\n", - "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ." + "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ.\n", + "\n", + "- For `optimization_level=1`, this stage will prepare the [`Optimize1qGatesDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition.md) and [`CXCancellation`](../api/qiskit/qiskit.transpiler.passes.CXCancellation.md) which will combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n", + "- For `optimization_level=2`, this stage will use the [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation.md) pass instead of `CXCancellation` which remove redundant gates by exploiting commutation relations.\n", + "- For `optimization_level=3` this stage will prepare the following passes:\n", + " - [`Collect2qBlocks`](../api/qiskit/qiskit.transpiler.passes.Collect2qBlocks.md)\n", + " - [`ConsolidateBlocks`](../api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks.md)\n", + " - [`UnitarySynthesis`](../api/qiskit/qiskit.transpiler.passes.UnitarySynthesis.md)\n", + " - [`Optimize1qGateDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition.md)\n", + " - [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation.md)\n", + "\n", + "\n", + "Additionally, this stage will also execute a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend." ] }, { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "## Scheduling\n", + "\n", + "Once the circuit has been translated to the target basis, mapped to the device, and optimized, a scheduling pass will be applied to account for all the idle time in the circuit. At a high level, the scheduling pass can be thought of as inserting delay instructions to account for the idle time between gate executions. The scheduling of a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis.md)) which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay.md) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling.md) are executed" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -200,7 +231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.6" }, "title": "Transpiler Stages & the PassManager" }, From 31143340ac8bb7329c9afe0c695851ecad7cb161 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Thu, 9 Nov 2023 16:15:29 -0500 Subject: [PATCH 28/48] Finished first draft of default passmanagers --- docs/transpile/passmanagers.ipynb | 21 +-------------------- 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 61e83d6bf14..6b64f9b0c72 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -190,27 +190,8 @@ "source": [ "## Scheduling\n", "\n", - "Once the circuit has been translated to the target basis, mapped to the device, and optimized, a scheduling pass will be applied to account for all the idle time in the circuit. At a high level, the scheduling pass can be thought of as inserting delay instructions to account for the idle time between gate executions. The scheduling of a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis.md)) which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay.md) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling.md) are executed" + "This last stage is only run if it is explicitly called for (similar to the Init stage) and does not run by default (though a method can be specified by setting the `scheduling_method` argument when calling `transpile()`). The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized. These passes will focus on accounting for all the idle time in a circuit. At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend. Scheduling a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis.md)) which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay.md) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling.md) can be executed." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 549cef10353db8028c0850caf60a800681a56838 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Thu, 9 Nov 2023 16:21:40 -0500 Subject: [PATCH 29/48] Fixed typo --- docs/transpile/passmanagers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 6b64f9b0c72..008d64a04b0 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -53,7 +53,7 @@ "Then for the heuristic stage, 2 passes are used by default:\n", "\n", "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", - "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. More details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" + "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. For more details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" ] }, { From 1e5aacb513a976646d93257b7107a1e1a740296f Mon Sep 17 00:00:00 2001 From: abbycross Date: Fri, 10 Nov 2023 10:55:58 -0500 Subject: [PATCH 30/48] Update docs/transpile/passmanagers.ipynb --- docs/transpile/passmanagers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 008d64a04b0..d5e81f4e3fe 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -66,7 +66,7 @@ "\n", "However this may come as no surprise that there's no free lunch here and that finding the optimal swap mapping is hard. In fact it is what is known as an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To get around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal swap mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly will result in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run routing function (or the entire `StagedPassManager`) many times and select the lowest depth circuits from the distribution of outputs.\n", "\n", - "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit.transpiler.passes.SabreLayout). " + "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " ] }, { From 0ee0bf7e41517c0517a4e32be440e2e1b74adcc9 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 10 Nov 2023 12:00:23 -0500 Subject: [PATCH 31/48] tidy-up edits --- docs/transpile/_toc.json | 2 +- docs/transpile/passmanagers.ipynb | 78 +++++++++++++++---------------- 2 files changed, 40 insertions(+), 40 deletions(-) diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index c09c82e6d57..21f44d221d3 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -6,7 +6,7 @@ "url": "/transpile" }, { - "title": "Preset PassManagers", + "title": "Preset pass managers", "url": "/transpile/passmanagers" } ] diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index d5e81f4e3fe..9eb3f66a5a7 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -4,22 +4,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - " # Transpiler Stages & Preset PassManagers\n", + " # Transpiler stages and preset pass managers\n", "\n", - "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of different `Passes` which can include things like transforming the operations in your quantum circuit, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise. In this document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", + "Qiskit includes functions to build preset `PassManager` objects. These are objects that manage a set of different `Passes`, which can include things like transforming the operations in your quantum circuit, optimizing the selection of qubits to be used on the target backend, and other optimizations that improve the overall efficiency of your circuit and suppress the effects of noise. This page details the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", "\n", "\n", - "When the `transpile()` function is called, a preset `StagedPassManager` object is created and then executed. There are 4 different preset pass managers ranging from very light to heavy optimization and specified by the `optimization_level` argument which can range from 0 to 3. Higher optimization levels take more time and computational effort but may yield more optimal circuits. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic based, spending more computational effort does not always result in an improvement in the quality of the output circuit. For specific details on the preset pass managers, look to the [API reference section](../api/qiskit/transpiler_preset.md).\n", + "When the `transpile()` function is called, a preset `StagedPassManager` object is created and then executed. The four different preset pass managers range from very light to heavy optimization, which is specified by the `optimization_level` argument that can range from 0 to 3. Higher optimization levels take more time and computational effort but may yield more optimal circuits. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic-based, spending more computational effort does not always result in an improvement in the quality of the output circuit. For specific details on the preset pass managers, look to the [API reference section](../api/qiskit/transpiler_preset).\n", "\n", - "We'll now expand upon each stage of these preset pass managers which provide a useful framework for optimizing your quantum algorithms. Recall that these stages are:\n", + "The four stages of the preset pass managers provide a useful framework for optimizing your quantum algorithms. Recall that these stages are:\n", "\n", "\n", "1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates.\n", "1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend.\n", - "1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map.\n", + "1. `routing` - This pass runs after a layout has been applied and injects gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map.\n", "1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions.\n", "1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth).\n", - "1. `scheduling` - This pass is for any hardware-aware optimizations that improves the efficiency of the executed microwave pulse instructions.\n", + "1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions.\n", "\n", "\n" ] @@ -28,56 +28,56 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Init Stage\n", + "## Init stage\n", "\n", - "This first stage does very little by default and is primarily useful if you would want to include your own initial optimizations. Because most layout and routing algorithms are only designed to work with 1 and 2 qubit gates, this stage is also used to translate any gates that operate on more than 2 qubits into gates that only operate on 1 or 2 qubits.\n", + "This first stage does very little by default and is primarily useful if you want to include your own initial optimizations. Because most layout and routing algorithms are only designed to work with single- and two-qubit gates, this stage is also used to translate any gates that operate on more than two qubits into gates that only operate on one or two qubits.\n", "\n", - "For more information about utilizing your own initial optimizations you would like to run for this stage, see the section on plugins and customizing pass managers." + "For more information about implementing your own initial optimizations for this stage, see the section on plugins and customizing pass managers." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Layout Stage\n", - "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. In order to execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device. This mapping is stored as a `Layout` object.\n", + "## Layout stage\n", + "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. To execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device is necesary. This mapping is stored as a `Layout` object.\n", "\n", "\n", - "![Qubit Mapping](/images/transpile/layout-mapping.png)\n", + "![Qubit mapping](/images/transpile/layout-mapping.png)\n", "\n", - "The choice of mapping is extremely important for minimizing the number of swap operations needed to map the input circuit onto the device topology ancd ensure the most well-calibrated qubits are utilized. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves 2 steps: first, trying to find a \"perfect\" layout (a layout which does not require any swap operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are 2 `Passes` typically used for this first step:\n", + "The choice of mapping is extremely important for minimizing the number of SWAP operations needed to map the input circuit onto the device topology and ensure the most well-calibrated qubits are used. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves two steps: first, try to find a \"perfect\" layout (a layout that does not require any SWAP operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are two `Passes` typically used for this first step:\n", "\n", - "- `TrivialLayout`: Naively maps each virtual qubit to same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", - "- `VF2Layout`: This is an `AnalysisPass` which works to select an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", + "- `TrivialLayout`: Naively maps each virtual qubit to the same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", + "- `VF2Layout`: This is an `AnalysisPass` that selects an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", "\n", - "Then for the heuristic stage, 2 passes are used by default:\n", + "Then for the heuristic stage, two passes are used by default:\n", "\n", "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", - "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. For more details on this algorithm please refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" + "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. For more details on this algorithm, refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Routing Stage\n", + "## Routing stage\n", "\n", - "In order to implement a 2-qubit gate between qubits that are not directly connected on a quantum device, one or more swap gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each swap gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of swap gates needed to map a circuit onto a given device is an important step in the whole transpilation process. For efficiency, this stage typically computed alongside the Layout stage by default, but they are logically distinct from one another. The *Layout* stage selects the hardware qubits to be used and the *Routing* stage inserts the appropriate amount of swap gates in order to execute the circuits using the selected layout.\n", + "In order to implement a two-qubit gate between qubits that are not directly connected on a quantum device, one or more SWAP gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each SWAP gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of SWAP gates needed to map a circuit onto a given device is an important step in the whole transpilation process. For efficiency, this stage is typically computed alongside the Layout stage by default, but they are logically distinct from one another. The *Layout* stage selects the hardware qubits to be used, while the *Routing* stage inserts the appropriate amount of SWAP gates in order to execute the circuits using the selected layout.\n", "\n", - "However this may come as no surprise that there's no free lunch here and that finding the optimal swap mapping is hard. In fact it is what is known as an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To get around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal swap mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly will result in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run routing function (or the entire `StagedPassManager`) many times and select the lowest depth circuits from the distribution of outputs.\n", + "However this may come as no surprise that there's no free lunch here and that finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, swap mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n", "\n", - "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default `SabreLayout` will run both layout and routing and will return the transformed circuit. This is done for a few particular technical reasons that is specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " + "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit. This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Translation Stage\n", + "## Translation stage\n", "\n", - "When writing a quantum circuit you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions. However, most quantum devices only natively support a handful of quantum gate and non-gate operations. This stage of the preset `PassManagers` will translate (or *unroll*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step as it allows the circuit to be executed by the backend, but will typically lead to an increase in the depth and the number of gates.\n", + "When writing a quantum circuit, you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions. However, most quantum devices only natively support a handful of quantum gate and non-gate operations. This stage of the preset `PassManagers` translates (or *unrolls*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step, as it allows the circuit to be executed by the backend, but typically leads to an increase in the depth and number of gates.\n", "\n", - "There two special cases which are especially important to highlight, and illustrate a bit more clearly what this stage does:\n", + "There two special cases which are especially important to highlight, and which help illustrate what this stage does:\n", "\n", "1. If a swap gate is not a native gate to the target backend, this requires three CNOT gates:" ] @@ -122,7 +122,7 @@ "source": [ "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of swap gates in a circuit is a primary goal in the process of transpilation.\n", "\n", - "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate. Given that our basis gate set includes only single and two-qubit gates, it is obvious that this operation must be decomposed. However it is quite costly:" + "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate. Given that our basis gate set includes only single- and two-qubit gates, this operation must be decomposed. However, it is quite costly:" ] }, { @@ -160,28 +160,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates, and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affect by noise." + "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affected by noise." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimization Stage\n", + "## Optimization stage\n", "\n", - "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, many routines for optimizing circuit by either combining or eliminating gates exist. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ.\n", + "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, there are many routines for optimizing circuits by either combining or eliminating gates. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ.\n", "\n", - "- For `optimization_level=1`, this stage will prepare the [`Optimize1qGatesDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition.md) and [`CXCancellation`](../api/qiskit/qiskit.transpiler.passes.CXCancellation.md) which will combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n", - "- For `optimization_level=2`, this stage will use the [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation.md) pass instead of `CXCancellation` which remove redundant gates by exploiting commutation relations.\n", - "- For `optimization_level=3` this stage will prepare the following passes:\n", - " - [`Collect2qBlocks`](../api/qiskit/qiskit.transpiler.passes.Collect2qBlocks.md)\n", - " - [`ConsolidateBlocks`](../api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks.md)\n", - " - [`UnitarySynthesis`](../api/qiskit/qiskit.transpiler.passes.UnitarySynthesis.md)\n", - " - [`Optimize1qGateDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition.md)\n", - " - [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation.md)\n", + "- For `optimization_level=1`, this stage prepares the [`Optimize1qGatesDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition) and [`CXCancellation`](../api/qiskit/qiskit.transpiler.passes.CXCancellation), which combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n", + "- For `optimization_level=2`, this stage uses the [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation) pass instead of `CXCancellation`, which removes redundant gates by exploiting commutation relations.\n", + "- For `optimization_level=3`, this stage prepares the following passes:\n", + " - [`Collect2qBlocks`](../api/qiskit/qiskit.transpiler.passes.Collect2qBlocks)\n", + " - [`ConsolidateBlocks`](../api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks)\n", + " - [`UnitarySynthesis`](../api/qiskit/qiskit.transpiler.passes.UnitarySynthesis)\n", + " - [`Optimize1qGateDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition)\n", + " - [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation)\n", "\n", "\n", - "Additionally, this stage will also execute a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend." + "Additionally, this stage also executes a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend." ] }, { @@ -190,7 +190,7 @@ "source": [ "## Scheduling\n", "\n", - "This last stage is only run if it is explicitly called for (similar to the Init stage) and does not run by default (though a method can be specified by setting the `scheduling_method` argument when calling `transpile()`). The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized. These passes will focus on accounting for all the idle time in a circuit. At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend. Scheduling a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis.md)) which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay.md) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling.md) can be executed." + "This last stage is only run if it is explicitly called for (similar to the Init stage) and does not run by default (though a method can be specified by setting the `scheduling_method` argument when calling `transpile()`). The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized. These passes focus on accounting for all the idle time in a circuit. At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend. Scheduling a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis)), which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling) can be executed." ] } ], @@ -214,7 +214,7 @@ "pygments_lexer": "ipython3", "version": "3.11.6" }, - "title": "Transpiler Stages & the PassManager" + "title": "Transpiler stages and the pass manager" }, "nbformat": 4, "nbformat_minor": 2 From 8b8d16f9a551717e8251532728624749674f1964 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 10 Nov 2023 12:07:18 -0500 Subject: [PATCH 32/48] updates from Kaelyn --- docs/transpile/passmanagers.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb index 9eb3f66a5a7..6fdc3d99e43 100644 --- a/docs/transpile/passmanagers.ipynb +++ b/docs/transpile/passmanagers.ipynb @@ -52,7 +52,7 @@ "\n", "Then for the heuristic stage, two passes are used by default:\n", "\n", - "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for )\n", + "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for optimization level 1 if there are control flow operations (such as IfElseOp) present in the circuit).\n", "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. For more details on this algorithm, refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" ] }, @@ -64,7 +64,7 @@ "\n", "In order to implement a two-qubit gate between qubits that are not directly connected on a quantum device, one or more SWAP gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each SWAP gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of SWAP gates needed to map a circuit onto a given device is an important step in the whole transpilation process. For efficiency, this stage is typically computed alongside the Layout stage by default, but they are logically distinct from one another. The *Layout* stage selects the hardware qubits to be used, while the *Routing* stage inserts the appropriate amount of SWAP gates in order to execute the circuits using the selected layout.\n", "\n", - "However this may come as no surprise that there's no free lunch here and that finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, swap mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n", + "However this may come as no surprise that there's no free lunch here and that finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, SWAP mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n", "\n", "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit. This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " ] @@ -79,7 +79,7 @@ "\n", "There two special cases which are especially important to highlight, and which help illustrate what this stage does:\n", "\n", - "1. If a swap gate is not a native gate to the target backend, this requires three CNOT gates:" + "1. If a SWAP gate is not a native gate to the target backend, this requires three CNOT gates:" ] }, { @@ -120,7 +120,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of swap gates in a circuit is a primary goal in the process of transpilation.\n", + "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of SWAP gates in a circuit is a primary goal in the process of transpilation.\n", "\n", "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate. Given that our basis gate set includes only single- and two-qubit gates, this operation must be decomposed. However, it is quite costly:" ] From 09d3d9bf1644836e6ea55a33e9f87ced5c19c39a Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 16:49:07 -0500 Subject: [PATCH 33/48] Content and toc update --- .gitignore | 2 + docs/transpile/_toc.json | 4 + docs/transpile/customized-passmanagers.ipynb | 230 ++++++++++++++++++- 3 files changed, 228 insertions(+), 8 deletions(-) diff --git a/.gitignore b/.gitignore index 2d11cd3c41e..5259b7674d4 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ node_modules tsconfig.tsbuildinfo .out/ +pyproject.toml +poetry.lock diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index c09c82e6d57..ff5ca48a1b4 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -8,6 +8,10 @@ { "title": "Preset PassManagers", "url": "/transpile/passmanagers" + }, + { + "title": "Customizing Transpilation", + "url": "/transpile/customized-passmanagers" } ] } diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 7311511dba5..b21a9b5e21a 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -4,28 +4,242 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Transpiler Stages & the PassManager\n", + "# Customizing the PassManager \n", "\n", - "Qiskit includes functions to build preset `PassManager` objects. These are objects which manage a set of passes which can include things like transforming the operations in your quantum circuit into single and two qubit gates, optimize the selection of qubits to be used on the target backend, and other optimizations which improve the overall efficiency of your circuit and suppress the effects of noise.\n", + "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Utilizing the `StagedPassManager`\n", + "\n", + "This class enables building a transpilation pipeline from a set of stages. Each `StagedPassManager` contains a list of stages which are executed in a fixed order, with each stage specified by its own `PassManager` instance. Each stage can also be prepended or appended with a `pre_` and `post_` which are particularly useful if you would like to add other `PassManagers` that contain conditional logic and programatically control the flow of passes.\n", + "\n", + "Note that when using a `StagedPassManager` you are not able to modify the individual passes, only the stages and their associated passes or passmanagers. The default stages are the same that have been specified in previous sections:\n", + "\n", + "1. `init` - any initial passes that are run before we start embedding the circuit to the backend\n", + "1. `layout` - This stage runs layout and maps the virtual qubits in the circuit to the physical qubits on a backend\n", + "1. `routing` - This stage runs after a layout has been run and will insert any necessary gates to move the qubit states around until it can be run on backend’s coupling map.\n", + "1. `translation` - Perform the basis gate translation, in other words translate the gates in the circuit to the target backend’s basis set\n", + " optimization - The main optimization loop, this will typically run in a loop trying to optimize the circuit until a condition (such as fixed depth) is reached.\n", + "1. `scheduling` - Any hardware aware scheduling passes\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using your own `PassManager`\n", + "\n", + "As has been mentioned before, the `PassManager` object is used to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ALAPSchedule',\n", + " 'ALAPScheduleAnalysis',\n", + " 'ASAPSchedule',\n", + " 'ASAPScheduleAnalysis',\n", + " 'AlignMeasures',\n", + " 'ApplyLayout',\n", + " 'BIPMapping',\n", + " 'BarrierBeforeFinalMeasurements',\n", + " 'BasicSwap',\n", + " 'BasisTranslator',\n", + " 'CSPLayout',\n", + " 'CXCancellation',\n", + " 'CXDirection',\n", + " 'CheckCXDirection',\n", + " 'CheckGateDirection',\n", + " 'CheckMap',\n", + " 'Collect1qRuns',\n", + " 'Collect2qBlocks',\n", + " 'CollectCliffords',\n", + " 'CollectLinearFunctions',\n", + " 'CollectMultiQBlocks',\n", + " 'CommutationAnalysis',\n", + " 'CommutativeCancellation',\n", + " 'CommutativeInverseCancellation',\n", + " 'Commuting2qGateRouter',\n", + " 'ConsolidateBlocks',\n", + " 'ConstrainedReschedule',\n", + " 'ContainsInstruction',\n", + " 'ConvertConditionsToIfOps',\n", + " 'CountOps',\n", + " 'CountOpsLongestPath',\n", + " 'CrosstalkAdaptiveSchedule',\n", + " 'DAGFixedPoint',\n", + " 'DAGLongestPath',\n", + " 'Decompose',\n", + " 'DenseLayout',\n", + " 'Depth',\n", + " 'DynamicalDecoupling',\n", + " 'EchoRZXWeylDecomposition',\n", + " 'EnlargeWithAncilla',\n", + " 'Error',\n", + " 'FixedPoint',\n", + " 'FullAncillaAllocation',\n", + " 'GateDirection',\n", + " 'GatesInBasis',\n", + " 'HighLevelSynthesis',\n", + " 'HoareOptimizer',\n", + " 'InstructionDurationCheck',\n", + " 'InverseCancellation',\n", + " 'Layout2qDistance',\n", + " 'LayoutTransformation',\n", + " 'LinearFunctionsSynthesis',\n", + " 'LinearFunctionsToPermutations',\n", + " 'LookaheadSwap',\n", + " 'MergeAdjacentBarriers',\n", + " 'MinimumPoint',\n", + " 'NoiseAdaptiveLayout',\n", + " 'NumTensorFactors',\n", + " 'Optimize1qGates',\n", + " 'Optimize1qGatesDecomposition',\n", + " 'Optimize1qGatesSimpleCommutation',\n", + " 'OptimizeCliffords',\n", + " 'OptimizeSwapBeforeMeasure',\n", + " 'PadDelay',\n", + " 'PadDynamicalDecoupling',\n", + " 'PulseGates',\n", + " 'RZXCalibrationBuilder',\n", + " 'RZXCalibrationBuilderNoEcho',\n", + " 'RemoveBarriers',\n", + " 'RemoveDiagonalGatesBeforeMeasure',\n", + " 'RemoveFinalMeasurements',\n", + " 'RemoveResetInZeroState',\n", + " 'ResetAfterMeasureSimplification',\n", + " 'ResourceEstimation',\n", + " 'SabreLayout',\n", + " 'SabreSwap',\n", + " 'SetIOLatency',\n", + " 'SetLayout',\n", + " 'Size',\n", + " 'SolovayKitaev',\n", + " 'SolovayKitaevSynthesis',\n", + " 'StochasticSwap',\n", + " 'TemplateOptimization',\n", + " 'TimeUnitConversion',\n", + " 'TranslateParameterizedGates',\n", + " 'TrivialLayout',\n", + " 'UnitarySynthesis',\n", + " 'Unroll3qOrMore',\n", + " 'UnrollCustomDefinitions',\n", + " 'UnrollForLoops',\n", + " 'Unroller',\n", + " 'VF2Layout',\n", + " 'VF2PostLayout',\n", + " 'ValidatePulseGates',\n", + " 'Width']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.transpiler import passes\n", + "\n", + "[pass_ for pass_ in dir(passes) if pass_[0].isupper()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A `PassManager` can be created using a list of passes to execute, or, once instantiated, can have passes appended to it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaelyn/projects/Notes/qiskit-documentation/.venv/lib64/python3.11/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit.compiler import transpile\n", + "from qiskit.transpiler import PassManager\n", + "\n", + "\n", + "circ = QuantumCircuit(3)\n", + "circ.ccx(0, 1, 2)\n", + "circ.draw(output='mpl')\n", "\n", - "In the document, we will look at the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object. However, it is important to first introduce the internal represenation of quantum circuits in Qiskit, the *Directed Acyclic Graph* or **DAG**. Before you start however, you may need to install the `pydot` library and the `graphivz` library for the DAG plotting functions. Use `pip` to install `pydot` and your system's native package manager (e.g. `apt`, `brew`, `yum`, `dnf`, etc.) for `graphivz`.\n", "\n" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzQAAADuCAYAAADvP0KjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1rElEQVR4nO3deXxV9b3v/9fOPJAACUMiCQRCmOcgg6KIBYcqDm1BK9Va9arnysGeeoTb2nPUnqtWD4/+/KltxXNora0DxeFQwQEURETAIDMhEIYAmSAhEJKQkGHv+8eSIZCQvXf2Xmuvlffz8cgDkjV94Pv9rqzPXt/B5fF4PIiIiIiIiNhQmNUBiIiIiIiI+EsJjYiIiIiI2JYSGhERERERsS0lNCIiIiIiYltKaERERERExLaU0IiIiIiIiG0poREREREREdtSQiMiIiIiIralhEZERERERGxLCY2IiIiIiNiWEhoREREREbEtJTQiIiIiImJbSmhERERERMS2lNCIiIiIiIhtKaERERERERHbUkIjIiIiIiK2pYRGRERERERsSwmNiIiIiIjYlhIaERERERGxLSU0IiIiIiJiW0poRERERETEtpTQiIiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JYSGhERERERsS0lNCIiIiIiYltKaERERERExLaU0IiIiIiIiG0poREREREREdtSQiMiIiIiIralhEZERERERGxLCY2IiIiIiNiWEhoREREREbEtJTQiIiIiImJbSmhERERERMS2IqwOQERERETkQh6PBxqarA7DN5HhuFwuq6PocJTQiIiIiEjoaWii8YnFVkfhk4hnZkCUHq/Npi5nIiIiIiJiW0poRERERETEtpTQiIiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JYSGhERERFxjDd2rCZq/l28sWN1i9sLKsuImn8X93/8qsmRSbAooREREREREdtSQiMiIiIiIralhEZERERERGxLCY2IiIiIiNiWEhoREREREbGtCKsDMEN5eTkvvPAC77//PoWFhXTv3p0f/OAHPPvss8yZM4c//elPvPzyy8yePdvqUEUkCBqbYNthyC2C2gaIioD0JBjXDzrFWB2diJihvArW74Oyk9DkgYQYGN0HsnqCy2V1dMFX3wibD8KeUqj77j7Yrztc3g9iIq2OTsxQVWu0gaLj0NAEcVEwLM34Crf5Kw7HJzRbtmzhxhtvpLS0lPj4eIYMGUJxcTEvvfQS+/bto6KiAoBRo0ZZG6iIBJzHA1/uhs92QlVd822bD8JHW2FsX7g9G6L1C13EkSqq4d0c2FUMngu2rdsLPRLhltHGQ50Tud3w6Q5YsxtO1TfftvkgLN0CE/rD9FEQEW5FhNY5P49dnLee32/+hK1HD9ItNoH8B1+yLK5AO3Ua3t8Imw9Bk7v5tpwD0DkWrh8OV2RZE18g2Dwfu7Ty8nKmT59OaWkpjz32GCUlJWzatInS0lKef/55li1bRk5ODi6XixEjRlgdrogEkMcD738LH3x7cTJzRqPb+LTqlc+gtr7lfUTEvo6ehBc/hdwWkpnz91m4GtbvNTU0U7jd8MZa+HT7xcnMGacbYXUevPaF8TbbCWIiogA41dDyP7qm4TQAsd/tB9A1Jp5/Gn0dv5k0M/gBmqi6Dl5aARsLLk5mzqishb9/A8u2mBlZYDk6oZkzZw6FhYXMnj2b+fPnk5CQcHbb3LlzGTlyJI2NjWRkZJCYmGhhpCISaF/tMT6R9MbhCvjr2uDGIyLmqm+EBavgZCsfaJzPg/FAt+9I0MMy1cfbYMsh7/bdU2q8yXKCvp27A5BXUdTi9rxjxs8zvtsPYGrGcO4YdAW9E7sFP0CTeDzwpy+htNK7/VfshG/2BzemYHFsQrNr1y4WLVpEt27deO6551rcJzs7G4CRI0c2+/mBAwe45ZZbSEhIoGvXrtxzzz0cO3Ys6DGLSGA0uY1uZr7ILYbCiuDEIyLm21QAx6q939/tgc9ygxaO6eoaYLWXH+qc8c1+OHEqOPGYaXTPvqQnJPP3vHUUVx9vtq2+qZE/bl6OCxc398+2KEJz7DsK+8t8O2bFDqMt2I1jE5q3334bt9vNrFmz6NSpU4v7xMbGAs0TmqqqKqZMmUJhYSFvv/02r732GmvWrOHmm2/G7W7lXZ2IhJQdhcYrdF+tzQ98LCJiPo/HeEvrq7xiY/IAJ8jZb7yl8oXbY4wrsruIsHBennofladPkf2Xefxy9dv899bPeWbd+4x741d8WbiLueNvYWDSZVaHGlT+tIGyKsgvDXwswebYSQFWrlwJwJQpU1rdp7CwEGie0Lz22msUFRXx5Zdf0rt3bwDS0tK44oor+Mc//sFtt90WvKBFJCB2FZt7nIiElprTUHi87f0u5AHySmBSQpu7hrz23AdvdMCw4u9njmb1j59ifs6H/G3nlxyrqyY+MppRPTJ4c+IcZgyaYHWIQZdX4t9xu4phYGpgYwk2xyY0Bw8eBKBPnz4tbm9sbGTtWqPT/PkJzdKlS5k0adLZZAZg4sSJ9OvXjw8//NCvhGbs2LGUltow3RWxqfGz/kj6iOk+H1d2vJq0tEFBiEhEzBSfnMGNc7/y69gnf/Mcu7/4fYAjMt81D79Ht77jfT5uZ95+0h64OggR+S42PJLcmc/6ffzY1EzeueXngQvICwOysqhtajD1mi1yufjRbw/7deif//oOs2/91wAH1LaUlBQ2btzo17GOTWhqamoAqK1tud/JokWLKC8vJyEhgb59+579eW5uLjNmzLho/6FDh5Kb61/n2tLSUoqKWh6YJiKBV3XCvzFv9bVVaqsiDhBf438X8WNHix1xH6iuOo4/w9tra06EzL8/LjLatGs1ud00uBtpcDfh8UBdYz0uXERH+Danf3FJCae+m0XNag2nTxEZHefzcScqjoRMHfCWYxOalJQUjh8/zqZNm5g4cWKzbSUlJTz++OMAjBgxAtd5K2odP36cLl26XHS+pKQkdu/2cXTdebGIiHnqjvnRcRioLNpGr169AhyNiJjOFUbN8ULiu3q/uIzH48HlcuGuKnDEfeDU0TzgBp+PqyrdGTL//thw8xYIezN3DQ98suDs94kv3kufxG4+r0dzWWpqaLyhAU4UbqV75sS2d7xAfcVeS+pAe56XHZvQTJ06lV27dvH8888zbdo0BgwYAEBOTg5333035eXlgDkLavr7+kxE/FPXAE++b6yv4IunZ1/P4GcLgxOUiJhqxQ5YttX7/V0uF2lJsPXrD3G52t4/1B2vgd8sMSZI8MWrv7mbXi/fHZygfOSpb6TxicWmXOueYZO5Z9jkdp9nT34+rqjQeLzefBD+4mPPy/hoWLPkZSLCXw5OUEHi2FnO5s6dS3JyMocPH2bo0KEMHz6crKwsxo0bR79+/bj22muBi6ds7tq1KydOnLjofBUVFSQlJZkRuoi0U0wkjM/07ZieifYbBCkirZuQCdE+PldOHogjkhmArvEwMt23Y/r3hF5dgxOPmG94GnT1scfZlVkQER6ceILJsQlNWloaa9as4aabbiImJoaCggKSkpJYsGABy5YtY88eo0vKhQnN4MGDWxwrk5uby+DBg02JXUTab/poyOzh3b7x0XD/ZAhzyIOMiEBCLPx0kvft+sosGNu37f3sZOZ4SO3i3b5d4+HuK4MajpgsIhweuMb4kM8bg1Lh+uFBDSloXB6Pry8j7a+6uprExERcLhdVVVXExZ1LX+fPn8+vfvUr9u/fT1qa0fd2w4YNTJgwgffff5/bb7/dqrBFxEf1jfD2euO1e2tSOsN9V0OPRPPiEhHz7CmFv66FqrqWt4eHwfeGwA0jnPmhRs1p499/qSl8M7rBz66Czr6PHw8qM7ucBUrEMzNCpsvZGcXH4c9rjDVmWuICLu8HM8fZ8+0MdNCE5kyCMnDgQPLy8pptO3nyJMOHD6dbt248/fTT1NXVMXfuXLp37866desIC3PsSy0RxzpyEr7Oh9wiY9E8DxARBg9OgayezuliIiIta2yCbYeNRSP3HjXGlYS5jPVWJmQab3OcrrDCWDx4TylUVBv3wchweGQq9EkOzfugEprAcXtgd4lRB3YWnWsD1wyGK/pDN5uvvdQhn863b98OXNzdDCAxMZGVK1eSmprKnXfeyQMPPMAVV1zB0qVLlcyI2FTPRLg9G564BRK/e3CJj4YBKaH5S1xEAisiHMZkGA/viTHGzxJiYNqwjpHMAKQlwR3j4d9uPXcfjIsy3s7oPuh8YS4YfBk8MLl5G7hltP2TGXDwLGeXcqmEBiAzM5OlS5eaGZKIiIiIiPihQ75yaCuhERERERFnem/3BmavWNjsZ3/Z/gVR8+9iSX6ONUFJu3TINzQrV660OgQRERERscCSvTn8ZMhVZ78vqCxj4fZVjE/tb2FU0h4dMqEREREREWc6UVfD6NfnUdtYT1pCMqebGjhQeZRZQybxytT7WFe0h4U3PAyA2+Pm4U9f48Vrf8rcL960OHLxlxIaEREREXGMLjHx3DH4ChKiYnhi4g9YfmArz29YwoLrH2RFwTYmXDaAyHDjEfjFjR8xsddAxqT0szhqaY8OOYZGRERERJxr29GDjOqRAcCmIwfO/v0f+Ru5NWssADvKDvPBnm/41YTbrAlSAkZvaERERETEUbZekNDcnJmNx+NhRcE2npt8FwBri/I4eLKcIQt/AUBpTSW7li+ktOYED42aZlXo4gclNCIiIiLiGEVVFbhc0CshCYAdZYf45YTbyCndx6DkXnSKMhZieWjUtGaJy9R3/oN/zr6BW7MutyRu8Z8SGhERERFxjC1HC86+nQHoHB3Pq1tWkBybwC39x1oXmASNEhoRERERcYybMsdwU+aYs9+vu/v/AjDyz4+zYuavWz3uszv/LeixSXAooRERERERx9v6s/+0OgQJEs1yJiIiIiIitqWERkREREREbEsJjYiIiIiI2JbG0IiIiIhI6IkMJ+KZGVZH4ZvIcKsj6JCU0IiIiIhIyHG5XBClR1Vpm7qciYiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JYSGhERERERsS0lNCIiIiIiYltKaERERERExLaU0IiIiIiIiG0poREREREREdtSQiMiIiIiIralhEZERERERGxLCY2IiIiIiNiWEhoREREREbEtJTQiIiIiImJbSmhERERERMS2lNCIiIiIiIhtRVgdgIiIiFzM4/FAQ5PVYfgmMhyXy2V1FOIQagPiLSU0IiIioaihicYnFlsdhU8inpkBUXq0kABRGxAvqcuZiIiIiIjYlhIaERERERGxLSU0IiIiIiJiW0poRERERETEtpTQiIiIiHQQTW7weKyOQqzi8ZwrfyfVA03DICIiIuJAHg8UlMOuYiisgEMVUF13bvvJWvjj55CWBANTIasnaMZhZ2lyw84i2HcUDh+DouNwutHYdrIOnv4A0pMhPQmGpUFqF0vD9ZsSGhEREREHaWiCb/bD2j1QfKL1/TzA7lLj6/Nc6J4AVw6ACZkQE2lWtBIMVbXwVT6s22skrq05fsr42nYYlm2FzB5wZRaM6gNhNkpuldCIiIiIOMTBcnhrHRw56fuxZVXwP9/C6jz48QQYkBL4+CS4PB74tgDe3win6n0/ft9R4+urPfDjiUaSawcaQyMiIuIgb+xYTdT8u3hjx+oWtxdUlhE1/y7u//hVkyOTYHJ74KOt8OJy/5KZ8x2vgT98Du/mGF2W7KajtoG6Blj4Jfzta/+SmfPtL4MXlhlveOxAb2hEREREbMztgXfWG93MAumrPXDiFNw7CSLCA3tuCaya0/DqSjhcEbhzNjTBog3GuKtpwwJ33mDQGxoRERERm/J44L2cwCczZ+wohL9+bSRNEppON8CCVYFNZs63bCt8kReccweKEhoRERERm9p0ENbmB/caWw/Bmt3BvYb47x+b4dCx4F5jySZjfFaoUpczERERERs6WWu8nfHVL26AxFjj+N994t0xS7fAkMuge6Lv15Pg2VPqe0LrT/l7PMZkE//6fYgMwe6HHeINTXl5OXPnzqV///7ExMSQnp7Oo48+Sk1NDffffz8ul4tXXnnF6jAliNwe45OFHYXGfOxHKq2OSETMVlUHeSXG9KT5pefWYhCxqyWb/Bv8nRgLXeKMP73V0GRMEiCho8ltjHHxlT/lD8ZkEytzfb+eGRz/hmbLli3ceOONlJaWEh8fz5AhQyguLuall15i3759VFQYHQ5HjRplbaASFHUNxgwda/OhvKr5tn7djfn2R9tsrnUR8U1BudFdZsuh5jM2xUTCuH5w9UDoZpOpSUXOqKyFzQfNvebuUiithJTO5l5XWrazCI5Vm3vNtXvge0NCb5IIRyc05eXlTJ8+ndLSUh577DGefPJJEhKM31ovvPAC8+bNIyIiApfLxYgRIyyOVgLteI0xSK60lbcx+8uMr22H4CdXhuYrVBFpny93wwcbjQUEL1TXYGzfsA9+djUMSjU9PEud/znO4rz1/H7zJ2w9epBusQnkP/iSZXGJd9bvtWag/to98MPLzb9uMNi9DXy1x/xrnqyD7YXGh8GhxNFdzubMmUNhYSGzZ89m/vz5Z5MZgLlz5zJy5EgaGxvJyMggMVGdQp3k1HfTF7aWzJxv62GjX6hmcBFxlg37jMXl2mrapxvhv1cbb3KcICYiCoBTDS33RappOA1A7Hf7AXSNieefRl/HbybNDH6AEhAbD1h03YLQ/33ZEdpAZa0xfsYKOUGaUa89HJvQ7Nq1i0WLFtGtWzeee+65FvfJzs4GYOTIkWd/diYBGjduHNHR0bhc6otkR1/k+baw2OaDRp96EXGG0w1GMuOtxib/BleHor6duwOQV1HU4va8Y8bPM77bD2BqxnDuGHQFvRO7BT9AabdTp6Gsqu39gqG2/uIu3KGmI7SBw0Ge1exSDlUYkwSEEscmNG+//TZut5tZs2bRqVOnFveJjTVGQ52f0Ozdu5f33nuPlJQULr/cIe9UO5jGJv9WtrXi1a2IBMfGAt8H/R+uCP7Up2YY3bMv6QnJ/D1vHcXVx5ttq29q5I+bl+PCxc39sy2KUNorWOuNeH39EG8nHaENWFkHquuMBVdDiWPH0KxcuRKAKVOmtLpPYWEh0DyhufrqqykpKQHgqaeeYu3atUGMUoJhd4kxm5GvdhQZK+3GRwc+JhExl7+LDH6zH3onBzYWs0WEhfPy1PuYseR3ZP9lHvcOm0Jmlx4cOVXJ4rz15B4rZN74WxmYdJnVoYqfvOlO7eTrt6UjtIHSExZfvxK6xlsbw/kcm9AcPGhM/dGnT8ujlhobG88mK+cnNGFhgX9pNXbsWEpL1Z/JLP0m3M2Y21vuZngpHg9cfsX3OHlEq4c52fd/lUNc51RKSktIS9NbWKc6U86++vsHn/Lz2+8PQkS+iw2PJHfms34d+/3M0az+8VPMz/mQv+38kmN11cRHRjOqRwZvTpzDjEETAhytYUBWFrVNDUE5d6A44R4waMo/M+yGeS1uO7PGyKUkxpz786nbW9+vtXVK/rBgIQ99+KSX0fpPbaB1k+77GykDr2lxW1t1wNvyh9brwL33P0TR9mXeBeullJQUNm70oa/weRyb0NTU1ABQW1vb4vZFixZRXl5OQkICffv2DWospaWlFBW13I9TAi/pxAm/jz1ypJQKlZWjNTU1nf1T7dK5mhr9W2SmtrY2ZOpFXGT7XhePTc3knVt+HphgvFRcUsKp7wZchyon3AMuO9n6K5Iza4x4IyzM+33PV11dZcr/ndpA6+rqWn6+Be/rgL/lD1BxrDyk2o9jE5qUlBSOHz/Opk2bmDhxYrNtJSUlPP744wCMGDEi6AP/U1JSgnp+aS6KGr+Oczc1khjrIrZXrwBHJKEkPDz87J+9VNaOVV99BJLTfT7Oc/p4yNSL2PBI067V5HbT4G6kwd2ExwN1jfW4cBEd4VsMl6WmhvwbGifcA+KiW398O9n6c+5ZiTHGw6zbbUzD6+u5YqLCTPm/UxtoXYSrqdVtbdUBb8v/UudK7BQb8DrQnudlxyY0U6dOZdeuXTz//PNMmzaNAQMGAJCTk8Pdd99NebkxP6cZC2r6+/pM/NPkhqc/aLuRXmhURgQv5e8ITlASMp5835juMjUl9ew4OnGedXv9W0H7j//xM9L/8LPAB+QHT30jjU8sNuVab+au4YFPFpz9PvHFe+mT2M3ntTj25OfjigrtRwsn3AP2lMIfPm95W0vdgy701O3GJ/Mn6+CpD3y//rP/NofshXN8P9BHagOt+3gbfLq95W1t1YH2lj/A50v/5vfbnWAI7btOO8ydO5e33nqLw4cPM3ToUAYNGkRdXR179+7lxhtvJCMjg08//bTZ+BlxhvAwmJjVekNvzaQBwYlHRMw3JgOWbDIWz/RW72RIt/mEAP66Z9hk7hk22eowxEtpXa29fnqStdcPBru1ASvLoFMMdG5jnJbZHDttc1paGmvWrOGmm24iJiaGgoICkpKSWLBgAcuWLWPPHmOOXiU0znTNIEjt7P3+2RmQ1TNo4YiIyaIj4Idjvd8/Mhx+ZM/x4dIBxUVD94S29wvKtaOgm0XXlnOsnI2xTzKE2jKNjn1DAzB48GCWLl160c+rq6spKCggLCyMYcOGWRCZBFtsFDx8LSxYBcUnLr3v6D7w4wmh1zhFpH0u7wf1jfBuDlxqDbiYSLjvavtP1ywdy+X94KOt5l93bF8I0+9LyyXGwsBUY6kKs13ez/xrtsXRCU1rdu7cicfjYcCAAcTFXdwB8N133wUgNze32fcZGRmMHevDR35iqc5x8Oh1sGG/sWjm0ZPNt2f1hCsHwIh03ZxFnOrKAUai8uUe2FwAje5z2+KiYHym0d00ueX1l0VC1oRMo2t1k7vtfQPpyixzryetm5RlfkKTGAvD08y9pjc6ZEKzfbsxuKK17mYzZsxo8fuf/vSnvP7660GNTQIrOhKuHghXDYDC4/DHz+FUPXSKhkemWh2diJghPRlmTYTbxsCz/4CaeoiPgidvhxAfvy7SqsRYGNMHcg6Yd81BqdDTh+7cElxDexnd/8qrzLvmVQOMscqhpkPeyttKaDyeS3VOEDtyuYwBdJHGbJ0h2RhFJLjioyHiu3tARLiSGbG/W8ZAbjHUmLD0T1SExpmFmrAwuGM8/P4zc66X2hmmDDbnWr7qkI91bSU0IiIiTvXe7g3MXrGw2c/+sv0LoubfxZL8HGuCEr8kxMAMP5KMk7Vw4pR3a9acMX2U8ycDuLBt2KFdZPU03pr4wp/yD3PBXRPPfSgUajrk51MrV660OgQRERFLLNmbw0+GXHX2+4LKMhZuX8X41P4WRiX+GtUHriqDNbu9P8abtWrON7qPMR7N6c5vG3ZqF9NHw+EKKCj3bn9fyx/g9uzQnta+QyY0IiIiTnWirobRr8+jtrGetIRkTjc1cKDyKLOGTOKVqfexrmgPC294GAC3x83Dn77Gi9f+lLlfvGlx5OKv27OhsclYUDbQRqTDT66w/+Q5l2oXC65/kIamxrNtw27tIioCHrwGXl0Fh44F/vzTR8FVAwN/3kBSQiMiIuIgXWLiuWPwFSRExfDExB+w/MBWnt+whAXXP8iKgm1MuGwAkeHGr/8XN37ExF4DGZMSgvOwitfCXDBznDG75/Lt4A7QUOCrB8KtY5wx7vRS7QLgi8O5Z9vG73KW2q5dxEXD//4evL0Oth4OzDmjvlvPa3xmYM4XTEpoREREHGbb0YM8MuZ6ADYdOcCoHhkA/CN/I7dmGcsP7Cg7zAd7vmHlnf9uVZgSQC4X3DAchl4Gb62Dkkr/z5XcyVifrb+NFpy+6s1/Z++J0ha3fXP3c6QnJrfaLuBc27Bzu4iJhHuvgs0H4b2N7ZssIqsn3DnBPlPaK6ERERFxmK1HD559WNt05AA3Z2bj8XhYUbCN5ybfBcDaojwOnixnyMJfAFBaU8mu5QsprTnBQ6OmWRW6tFN6Mjx2I3xbYKzBdrjC+2NTOhvrMl3eD6Jt9oS4ZtZv2tynpXYBNGsbb+ausXW7cLlgTAYMSDG6IK7NNyYA8NaAFKMODEuzVzdDm1VXERERuZSiqgpcLuiVkATAjrJD/HLCbeSU7mNQci86RcUA8NCoac0e0Ka+8x/8c/YN3JqluXntLiLc6CY0PtMYU7Gr2EhsCiug8hSc6ZGWGANpScbXwBTo18N4IHai1toF0KxtOKVddIqBacPg2iGQVwz7yozyL6ww1uMDo6yTOxnLWqQnwdA06Jlobdz+UkIjIiLiIFuOFjTrStM5Op5Xt6wgOTaBW/qPtS4wsUTvZOPrDI/HGGMT5nJu8tKS1trFgusf5H/ycxzbNsLDjERlaNq5n52pA04YG3WGEhoREREHuSlzDDdljjn7/bq7/y8AI//8OCtm/rrV4z6789+CHptYz+WC8A6UyJzRWrsAWLZvU6ttw4ntwol1QAmNiIhIB7D1Z/9pdQgiIUltw/4c9LJJREREREQ6GiU0IiIiIiJiW0poRERERETEtjSGRkREJBRFhhPxzAyro/BNZLjVEYiTqA2Il5TQiIiIhCCXywVR+jUtHZfagHhLXc5ERERERMS2lNCIiIiIiIhtKaERERERERHbUkIjIiIiIiK2pYRGRERERERsSwmNiIiIiIjYlhIaERERERGxLSU0IiIiIiJiW0poRERERETEtpTQiIiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JYSGhERERERsS0lNCIiIiIiYltKaERERERExLYirA5AWubxeKChyeowvBcZjsvlsjoKx7Bd+YPqQICpDojqgNiuDgS4/G337we1AYsooQlVDU00PrHY6ii8FvHMDIhSdQoYm5U/qA4EnOqAqA6IzepAwMvfZv9+UBuwirqciYiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JamYRBHO3UaCo/D4WNwtApO1Rs/r62Hr/ZAWhJc1kUTkjiVxwOVtUb5H66A4zXN60DOfqMO9EyEMH2840huD5SdNMq/sOJc+Z+qh2VbID0Z0pOgSxxoplVnamyC4hNGHSg+3rwOfLbTKP+0JIiPtjRMEWkHPcaJ47jdsKvESFjyisHTwj71TfBujvH3yHDIzoArBxi/2MT+TjfCpgKjDhQdb3mf+iZ4c53x94QYmNjf+Ooab1qYEkSVtbBuL6zLN/5+oYYmWLHz3PepnY17wNi+EBNpXpwSPMXH4at82HgA6hsv3t7QBEu3nPt+YIpRB4b2gnB9wCFiK0poxFF2l8Dib6C82vtjGppg/T7jK6snzBwP3ROCF6MEj9sDa/fAsq1Q1+D9cVV1sHyH8YA7IRNuGQ2xUcGLU4LndIPxkLo236gP3iqpND7k+HAz3DACJg/UWzu7qqiGv38DeSW+Hbe71PjqGg8zLochvYITn4gEnm7XDvLGjtVEzb+LN3asbnF7QWUZUfPv4v6PXzU5suCra4C/b4A/rvQtmblQ/hF4YRmszvPtYShUdOQ6UF4Ff/gc3tvoWzJzPo/H+FT/+WWwqziw8ZmlI9eB/CPwwkewZo//7fd0IyzZBC+tgCMnAxufWTpqHfB4jET2+WW+JzPnO14Dr30Bb6071z3NTjpq+Z9P/wcdjxIasb2qOnh5BXy9NzDna2iCD76Ft76GJndgzinBdbAcfvcJ7D0SmPOdOAULVsGa3YE5nwTf+r1GQnusHR9onK+gHP6/T2Df0cCcT4LL7Tbeyiz+xkhKA+Gb/fDScuN+ICKhTQmN2FrNafj9Z62Pk2iPjQXwt6+NX5QSug5XGG/mgvFJ6nsbldTYwfp98M4G4xP6QKprgAUr4UBZYM8rgeXxwKJvjLergVZaCa98BlUtjMMSkdChhEZsy+2B19cYv3CCZfNB+GR78M4v7VNdZ7xJ8beLmTfe22jf7mcdwb4jsGhD8M5f3wT/9YU+pQ9ln+fChn3BO395Ffz3ar2xFwllmhRAbGvtHqPPvC9+cQMkxsLJWqOLkjc+2wnD0qB3su8xSnC9m2MkNb7wpw4s2gDzbtJEAaHmdCO8td63NzP+lP+pemOM3v+6RlM7h5qSE/DxNt+O8acOHDwGq3bB1KE+hygiJtAbGrGlY9XGbES+Sow11ptIjPX+GLcH3l5nrGUgoWPrIdhyyPfj/KkDJ04ZA8UltCzb4vuYGX/KHyC3GHIO+HaMBJfbbQzc9/XNib914ONtwe0RICL+6xAJTXl5OXPnzqV///7ExMSQnp7Oo48+Sk1NDffffz8ul4tXXnnF6jDFB6tyja4gZimphG2HzbueXJrHY35XwA37jdmPJDRU1RkzWplp+XZ7zn7oVLuKjTF0Zmlyw8pc864nIt5zfJezLVu2cOONN1JaWkp8fDxDhgyhuLiYl156iX379lFRYdwNR40aZW2gJjrTY+J0YwOPfv46qw7toOxUFSmduvDI6Ot5ZMz1lsbXlroGaz4pXZsPYzLMv24wnN9rZnHeen6/+RO2Hj1It9gE8h98ybK4vHWgzOhqYiaPB77Oh5tGmXvdYLF7HVi/1/wxDeXVxlpXgy8z97rBYvc68JXJCS0Y4ypvHQPx0eZfO9DsXv6BYPfnITnH0QlNeXk506dPp7S0lMcee4wnn3yShARjxcQXXniBefPmERERgcvlYsSIERZH234xEUYH/1MNLU/3VNNwGoDY7/ZrdDfRM74zy370S/p16cG2skPc/O5v6RHXmRmDJpgTtB82FQRuWk5f7DtqdDdI6Wz+tb3lax0A6BoTzz+Nvo6jNZW89O3HwQ8yAMz+ZP6M9fuMRRdDeRXxjlAHPJ7ATdPuq6/zQz+h6Qh14Fg15FkwWUdDkzGd85TB5l/bWx2h/NvSUZ6H5JwQ/rXcfnPmzKGwsJDZs2czf/78s8kMwNy5cxk5ciSNjY1kZGSQmJhoYaSB0bdzdwDyKopa3J53zPh5xnf7xUfF8PSkmfTvmkKYK4xRPTK4OTObr4tCe55aXycCCKRArXMSLL7WAYCpGcO5Y9AV9E7sFvwAA8Sqcqiqg6MhvthiR6gDx6qt6/6372jgp4cOtI5QB/YdBauKQb8HQl9HeR6Scxyb0OzatYtFixbRrVs3nnvuuRb3yc7OBmDkyJFnf/buu+/ywx/+kD59+hAXF8egQYN44oknqK4O0GptQTS6Z1/SE5L5e946iqubL8xS39TIHzcvx4WLm/tnt3h8Q1MjXxXlMbx7bzPC9VuhiX2mQ+na3mhvHbCDk7VQaeGaEGb22fdHR6gDVrbDU/WBW7wzWDpCHbCyHer3QOjrKM9Dco5ju5y9/fbbuN1uZs2aRadOnVrcJzbWmOLk/IRm/vz59O7dm2effZa0tDS2bNnC008/zerVq/nyyy8JCwvdHDAiLJyXp97HjCW/I/sv87h32BQyu/TgyKlKFuetJ/dYIfPG38rApJb7Szz6+eskRMbyk6FXmRy59+oaoKzKuuuH+sNse+uAHVj9MHG4Asb1szaGS+kQdSAIC+n6dP0K6JbQ9n5W6Qh1oMjC+0BlrfHBiq+zpJmlI5R/WzrC85A059iEZuXKlQBMmTKl1X0KCwuB5gnNhx9+SPfu517DTp48me7duzNr1iy++uorrr76ap9jGTt2LKWlpT4dExseSe7MZ32+1vczR7P6x08xP+dD/rbzS47VVRMfGc2oHhm8OXFOq31BH1/1V9YX57N85hNEhfteLQZkZVHbFMTVDb8T1zWd7/+fda1uP7O+QGsSY879+dTtre/X2voE+QeKSUsb52W0/vO3/MH/OtBeZtWB3mN+yLg7/v8Wt7VV/tD+OvDmO//Do7fN9jJa/6kOtG7MD1+g37i7WtwWqHsAtF4H5jz2S/av/6uX0fpPdaB11z32BYk9+re4zYw6MGHS9zh5JPjdkcx+FmivQJe/FW3ALs9DTpSSksLGjRv9OtaxCc3BgwcB6NOnT4vbGxsbWbt2LdA8oTk/mTlj7NixABQVtdwXsy2lpaU+HxsX6f8UKmNTM3nnlp97vf9jK99g5aGdLJ/5BN3i/BtLVFxSwqnvBtkFU5emuEtuP7O+QFvCwrzb7yKucL/rgS/aU/7gex0IBNPqQP/W+/t4W/7gfx043dCoOtAKs+rAkLqWB/qCCfcAoKr6lOpAK8yqA25P6yucmlEHyo9VUBbidcAJ5W92G7DT85A059iEpqbGGDFaW9tyZ/tFixZRXl5OQkICffv2veS5Vq1aBcDgwf5Na5KSkuLzMbHhkX5dy1f/8vlfWHVoJyvu+DXd/Wy8AJelpprzhqZL10tuP9nG2IrEGOOXmNsNJy+xwnxr5/G4G+jVq1cbUbafWeUP0OR20+BupMHdhMcDdY31uHARHeFbDGbVgcSE+Fa3tVX+0P46EBURpjrQCrPqQEx067+6AnUPuNS5OsXHqA60wqw6EEbrC5GZUQeSk7oQ1eicOhCq5W9mG7Db85AT+fO8fIbL4wn1+Vr8M2TIEHbt2sUrr7zCI4880mxbSUkJ2dnZlJSUcOWVV/LVV1+1ep6ioiJGjx5NdnY2H39s3lSGnvpGGp9YHNRrHKwsI+u/HiU6PJKI88YGTeo1iA9/NM+nc0U8MwNXVPDz48YmmPd3/9efeOp24xO5E6fgqQ98P75fd5hznX/X9oUZ5X/GGztW88AnC5r9rE9iN5/XITCrDuw7Ai9/5v/x7a0D04aasxaN6kDrlu+Aj7b6d2x7yx/goSnmTN2sOtC6V1dCXol/x7a3DriA52ZCjAnP2mbVgVAtf7P+/XZ8HpLmHPs/PnXqVHbt2sXzzz/PtGnTGDBgAAA5OTncfffdlJeXA5deULO6uppbb72VqKgo/vSnP5kRtqn6dO5O/b++ZXUYPokIh9Qu1g0MT0+25rrBdM+wydwzbLLVYXitV5LxQGHVJzFpSRZdOIjsVgfSLS4Dq68fDHasA/4mNO3VPdGcZMZMdiv/QLPj85A0F7pTdrXT3LlzSU5O5vDhwwwdOpThw4eTlZXFuHHj6NevH9deey3QfPzM+Wpra5k+fToHDhxg+fLlpKammhm+XIKVDxNOfJCxm5hI44HCKqoD1rOyDLrEQacY664vBis/WNA9QCT0ODahSUtLY82aNdx0003ExMRQUFBAUlISCxYsYNmyZezZswdoOaFpaGjgRz/6ERs3buTjjz9myJAhZocvlzA0+N2WWxQeBgOV14YEq+pAahfo2voQHjFJpxjoY9HbUqvqnjSXlQKR4dZce4jqgEjIcWyXMzAG8S9duvSin1dXV1NQUEBYWBjDhg1rtu3M2jWff/45H330EePGBX+KXvHNkMugaxwcP2XudUemQ4I+mQ0JV2bBql3WXNfV+uRKYqIrB8DB1mdwD5pJA8y/plwsLgqyM2D9PnOv2ynG+F0gIqHFsW9oLmXnzp14PB6ysrKIi2s+Z+MjjzzC4sWL+Zd/+Rfi4uJYv3792a+ysjKLIpbzhYXBFVnmX/dKPciEjG4JMMjkt2XRETD20hMiiolG94H49s3o6rN+3Y23dBIarEguJ2YaYzlFJLR0yIRm+/btQMvdzc7MZPbb3/6WiRMnNvtatmyZqXFK664aaG7XnxHpxsOMhI7poyHMxLclN45w3kBgO4sMh5taHgIZFC4X3DLGvOtJ29KSYGyGedfrHAtT/Fu9QUSCTAnNBQoKCvB4PC1+3XvvvSZH6pv84yVc/daTDFn4Cyb+9dfsLC+0OqSgiYmEHwdnoeOLxEXBjMud3dXovd0bmL1i4dnv/7L9C6Lm38WS/BzrgmpDr65w3XBzrtW3O1w90JxrmeHC8gZ7lPmFJvaHAf4vW+CTKYMho5s517KKHe8Dt4811pUxw8zxEGfyW8Fgcco9oCUd6VlIzlFC4yCPLF/IAyOuJff+3/Gv46bzwMevWh1SUA1IgcmDfDvmZK2x9oA3CzCeMXM8JMT6dh27WbI3h1v6jwWgoLKMhdtXMT61v8VRtW3aUOjj40Omr3UgNgrummB0dXSK88sb7FXm53O54M7xvnU98+ce0Kur8YbO6ex4H4iPhjsn+PaBkz91YGJ/Z00I4ZR7QEs62rOQGBw9KUBrVq5caXUIAXe0ppJvjxzgoxm/BOAHA8bx889fZ+/xUvp3bf0jzBN1NYx+fR61jfWkJSRzuqmBA5VHmTVkEguuf9Cs8P1262ioroNvC7zb/3ef+Hb+H46FUb19DiuktFXGDU2NrCvaw8IbHsbtcfPwp6/x4rU/Ze4Xb1odepvCw+DBa+CVz6DkhHfH+FIHoiKM81s5TbQ/LlXmr0y972x5A7Yr8wsldYKHr4XffwZ1XizO7es9oHsCPDzFuhm1AsXJ94EhvYzE9p313q1P5WsdGJEOP7rcr9As05HuAefrqM9C0kETGicqrDpGSnwXIsKM37oul4v0xGQOVx27ZCPuEhPPHYOvICEqhicm/oDlB7by/IYltmnAYWEwa6Lx4LlubwDP64IZ44xP5eyurTL+4nAuEy4bQGR4BL/LWcrEXgMZk9LP4qi9Fx8Ns6fCa1/AwfLAnvd/XWPPbkaXKvMVBdvOljfAixs/sl2ZXyg96bs6sApO1gXuvGld4aEpznhD6/T7wPhMiAiDt9ZDkztw5x3b1+jeHG6zN7Qd7R5wRkd9FhIlNAJsO3qQR8ZcD8CmIwcY1SPD2oB8FBYGd4yHgSmwOAdqTrfvfJd1gbsm2mdF+Kve/Hf2nihtcds3dz9HemLyJcv4H/kbuTVrLDvKDvPBnm9Yeee/mxF2QMVHw5xpsGInLN8Obm8+pr2EEenGuCk7P8i2VuZnyhuwdZlfKC0J5t4E722EzQfbd64wF3xvCFw/3D4zWuk+ANl94bKu8NY6OFzRvnPFRsEPso2Exq7jJzvaPaC97P4s1NEpoXGItIRkSmtO0OhuIiIsHI/Hw+GTx0hPaHv1ua1HD55tuJuOHODmzOwgRxsco/pAZk9YtsXogtbQ5NvxnWLg6gFw7RD7PMQArJn1mzb3aa2MPR4PKwq28dzku3gzdw0HT5YzZOEvACitqWTX8oWU1pzgoVHTghZ/oISHwQ3DYXgafLgZ8kp8P0dKZ7humDElsF0fYs5oqczPL2+AtUV5ti7zC3WKgZ9OMsrvk21QfML3c2T1NGbQ623Rwp3+0n3AkNoFfn49rM6DL/J8GycDxn1kTB+4ebQxq5mddcR7gJ6FOi4lNA7RI74zo3tk8FbuV9wzbDLv7/mGXglJZ1+x/uyjP3Br1uXcltW8I3BRVQUuF/RKMF5H7Cg7xC8n3GZ2+AGTEGMMEJ0+Gr7ZD5sKjIea1rogREcYg8rHZxqLpdkpkfHWpco4p3Qfg5J70SkqhodGTWv2C2zqO//BP2ffwK1Z9uo83qurMaairArW7oGdRcbfW5MQA/17Gmsb9e9h/0QGWi/z88sbcEyZX2hEupHYHiiDtfmw9whUXuLBtluCsWDvlVnQs7N5cZqpI90HwsOMD6YmD4LthbB+LxSUtz7GKsxlJEKj+8CETCMxtruOeg/Qs1DHpYTGQX5/3f088PGr/HbDEhKjYvmvGx46u+3b0gPMHnPDRcdsOVrQ7LVq5+h4Xt2ywvb9RuOjjWlWpwyGxiYjqTl60nhr48KY9jm1qzHg18y1TKxwqTL+n/zmM904SfcEuC3b+Kqth8LjcLzGqA/hYUYdSUsyPoV1QhJzvtbKPDk2wbHlfSGXC/r1ML7ASGgKK4xJRJrcxocXXeKMOhAXZW2sZuiI94HwMGNSl1G9jW6ox6qg6ISR2Hg8xkQP3ROMbmp2n/ThQh35HqBnoY7J5fF42tnbXILBU99I4xOLA3KuslMnuWfZK3w841cBOV9LIp6ZgStK+XGgBLL8L2Xknx9nxcxf0yO+/R9Lqw4EVjDqQCDLuyWqA4Gl+4AEug7Y7R5gt2chUBuwiv7HO4DucYlBb8BiT1t/9p9WhyAmUnlLS1QvOo6OXNZ6FnI2m01EKCIiIiIico4SGhERERERsS0lNCIiIiIiYluaFCBEeTwe3xdSsVJkOC6nTRVlIduVP6gOBJjqgKgOiO3qQIDL33b/flAbsIgSGhERERERsS11ORMREREREdtSQiMiIiIiIralhEZERERERGxLCY2IiIiIiNiWEhoREREREbEtJTQiIiIiImJbSmhERERERMS2lNCIiIiIiIhtKaERERERERHbUkIjIiIiIiK2pYRGRERERERsSwmNiIiIiIjYlhIaERERERGxLSU0IiIiIiJiW0poRERERETEtpTQiIiIiIiIbSmhERERERER21JCIyIiIiIitqWERkREREREbEsJjYiIiIiI2JYSGhERERERsS0lNCIiIiIiYltKaERERERExLaU0IiIiIiIiG0poREREREREdv6fzKy6AVc9HfCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.transpiler.passes import Unroller\n", + "pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])\n", + "pm = PassManager(pass_)\n", + "new_circ = pm.run(circ)\n", + "new_circ.draw(output='mpl')\n" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "## DAG Representation\n", "\n", - "Before we begin diving into the preset `PassManagers`, it is important to first understand the representation of quantum circuits which are used for transpilation. In Qiskit, circuits are represented internally using a Directed Acyclic Graph (DAG). The advantage of this representation over a pure list of gates (i.e. a *netlist*) is that the flow of information between operators is explicit, making it easier to make transformation decisions. In general, a DAG is formed by *vertices* (also known as \"nodes\") and directed *edges* which connect pairs of vertices in a particular orientation. This representation is stored using `qiskit.dagcircuit.DAGCircuit` objects which are composed of invididual `DagNode` objects.\n", + "\n", + "However, before we start it is important to first introduce the internal representation of quantum circuits in Qiskit, the *Directed Acyclic Graph* or **DAG**. If you want to follow along here, you will need to install the `pydot` library and the `graphivz` library for the DAG plotting functions. Use the python package manager of your choice (such as `pip` or `conda`) to install `pydot` and your system's native package manager (e.g. `apt`, `brew`, `yum`, `dnf`, etc.) for `graphivz`.\n", + "\n", + "\n", + "In Qiskit, specifically within the transpilation stages, circuits are represented using a Directed Acyclic Graph (DAG). In general, a DAG is composed of *vertices* (also known as \"nodes\") and directed *edges* which connect pairs of vertices in a particular orientation. This representation is stored using `qiskit.dagcircuit.DAGCircuit` objects which are composed of invididual `DagNode` objects. The advantage of this representation over a pure list of gates (i.e. a *netlist*) is that the flow of information between operators is explicit, making it easier to make transformation decisions. \n", "\n", "Let's look at a simple example to understand the DAG a bit more by preparing a simple circuit which prepares a bell state and applies an $R_Z$ rotation depending on the outcome of a measurement." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -35,7 +249,7 @@ "
" ] }, - "execution_count": 5, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -63,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -96,7 +310,7 @@ "" ] }, - "execution_count": 6, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } From 23df57d5bebd7b964b1edb80fa00d7c11f6d6c15 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 16:49:32 -0500 Subject: [PATCH 34/48] Updated content --- docs/transpile/customized-passmanagers.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index b21a9b5e21a..5d136b51f23 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -4,9 +4,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Customizing the PassManager \n", + "# Customizing a transpilation pipeline\n", "\n", - "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" + "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and installing them as plugins. Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" ] }, { @@ -33,7 +33,7 @@ "source": [ "## Using your own `PassManager`\n", "\n", - "As has been mentioned before, the `PassManager` object is used to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins." + "The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins." ] }, { From f1b19070e04b19588154eb7c456b4caad97469d4 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 17:34:19 -0500 Subject: [PATCH 35/48] Finished scaffolding page --- docs/transpile/customized-passmanagers.ipynb | 201 ++++++++----------- 1 file changed, 87 insertions(+), 114 deletions(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 5d136b51f23..38da1a2a382 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -13,7 +13,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Utilizing the `StagedPassManager`\n", + "## Utilizing the StagedPassManager\n", "\n", "This class enables building a transpilation pipeline from a set of stages. Each `StagedPassManager` contains a list of stages which are executed in a fixed order, with each stage specified by its own `PassManager` instance. Each stage can also be prepended or appended with a `pre_` and `post_` which are particularly useful if you would like to add other `PassManagers` that contain conditional logic and programatically control the flow of passes.\n", "\n", @@ -24,16 +24,75 @@ "1. `routing` - This stage runs after a layout has been run and will insert any necessary gates to move the qubit states around until it can be run on backend’s coupling map.\n", "1. `translation` - Perform the basis gate translation, in other words translate the gates in the circuit to the target backend’s basis set\n", " optimization - The main optimization loop, this will typically run in a loop trying to optimize the circuit until a condition (such as fixed depth) is reached.\n", - "1. `scheduling` - Any hardware aware scheduling passes\n" + "1. `scheduling` - Any hardware aware scheduling passes\n", + "\n", + "\n", + "Let's look at a quick example:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pre_init\n", + "init\n", + "post_init\n", + "pre_translation\n", + "translation\n", + "post_translation\n" + ] + } + ], + "source": [ + "from qiskit.transpiler.passes import (\n", + " UnitarySynthesis,\n", + " Collect2qBlocks,\n", + " ConsolidateBlocks,\n", + " UnitarySynthesis,\n", + " Unroll3qOrMore\n", + ")\n", + "from qiskit.transpiler import PassManager, StagedPassManager\n", + "\n", + "basis_gates = [\"rx\", \"ry\", \"rxx\"]\n", + "init = PassManager([UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()])\n", + "translate = PassManager(\n", + " [\n", + " Collect2qBlocks(),\n", + " ConsolidateBlocks(basis_gates=basis_gates),\n", + " UnitarySynthesis(basis_gates),\n", + " ]\n", + ")\n", + "\n", + "staged_pm = StagedPassManager(\n", + " stages=[\"init\", \"translation\"], init=init, translation=translate\n", + ")\n", + "\n", + "for stage in staged_pm.expanded_stages:\n", + " print(stage)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code above will create a new `StagedPassManager` that has 2 stages, `init` and `translation`. These stages will be executed in order and any stage set to `None` will be skipped. This list is immutable and stored as a tuple once the `StagedPassManager` is instantiated. Additionally, if a stage is provided multiple times (i.e. at different relative positions), the associated passes, including `pre_` and `post_`, will run once per declaration in the order they were declared. If a `PassManager` is being used for more than 1 stage (e.g. a `Pass` covers both Layout and Routing) you will want to set that to the earliest stage in the sequence it covers." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Using your own `PassManager`\n", + "## Using your own PassManager\n", + "\n", + "In addition to modifying the preset pass managers, it is also possible to build an entirely custom pipeline for optimizing your quantum circuits. The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins which are covered later in this document.\n", "\n", - "The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins." + "\n", + "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset.md#stage-generator-functions) may also be useful for you when constructing custom passmanagers. They generate stages which provide common functionality used in many passmanagers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." ] }, { @@ -161,17 +220,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kaelyn/projects/Notes/qiskit-documentation/.venv/lib64/python3.11/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", - " self._style, def_font_ratio = load_style(self._style)\n" - ] - }, { "data": { "image/png": "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", @@ -179,7 +230,7 @@ "
" ] }, - "execution_count": 1, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -192,141 +243,63 @@ "\n", "circ = QuantumCircuit(3)\n", "circ.ccx(0, 1, 2)\n", - "circ.draw(output='mpl')\n", - "\n", - "\n" + "circ.draw(output='mpl', style='clifford')" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kaelyn/projects/Notes/qiskit-documentation/.venv/lib64/python3.11/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n", + " self._style, def_font_ratio = load_style(self._style)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 2, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from qiskit.transpiler.passes import Unroller\n", - "pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])\n", + "from qiskit.transpiler.passes import Unroll3qOrMore\n", + "pass_ = Unroll3qOrMore()\n", "pm = PassManager(pass_)\n", "new_circ = pm.run(circ)\n", - "new_circ.draw(output='mpl')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## DAG Representation\n", - "\n", + "new_circ.draw(output='mpl', style='clifford')\n", "\n", - "However, before we start it is important to first introduce the internal representation of quantum circuits in Qiskit, the *Directed Acyclic Graph* or **DAG**. If you want to follow along here, you will need to install the `pydot` library and the `graphivz` library for the DAG plotting functions. Use the python package manager of your choice (such as `pip` or `conda`) to install `pydot` and your system's native package manager (e.g. `apt`, `brew`, `yum`, `dnf`, etc.) for `graphivz`.\n", - "\n", - "\n", - "In Qiskit, specifically within the transpilation stages, circuits are represented using a Directed Acyclic Graph (DAG). In general, a DAG is composed of *vertices* (also known as \"nodes\") and directed *edges* which connect pairs of vertices in a particular orientation. This representation is stored using `qiskit.dagcircuit.DAGCircuit` objects which are composed of invididual `DagNode` objects. The advantage of this representation over a pure list of gates (i.e. a *netlist*) is that the flow of information between operators is explicit, making it easier to make transformation decisions. \n", - "\n", - "Let's look at a simple example to understand the DAG a bit more by preparing a simple circuit which prepares a bell state and applies an $R_Z$ rotation depending on the outcome of a measurement." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEvCAYAAABYNEogAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAk0ElEQVR4nO3deXxU9b3/8ddk3yERMCFhixAhgYAQoiBVY0FCAREV0SIVL0pptdBWCN6iRR+tIJpiRaQXrihVW0zF5YfgdhGoLMqOYkLZg1m1kSVkgyQzvz8iKTEJZCaTmXwn7+fjkUc4+2eS4Z3vfM8532Ox2Ww2RETEWF7uLkBERJpHQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBjOx90FSMNsNjhf7e4qms7PGywWd1fhOWw2G2VlZe4uwy5BQUFY9CZwCwV5K3W+GuZkuLuKpls4Efz1bnKasrIyQkJC3F2GXUpKSggODnZ3GW2SulZERAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXESaxMtLcdFaaXQMEQ8XGhrKwIEDGTBgAOHh4fj4+HDu3DmOHj3Krl27OHz4MDab7ZL78PX15Y033iAzM5Pf//73LqpcmkpBLuKBQkNDuffee5k2bRoDBgy45LrFxcW88847LF26lB07dtRbfiHEb7/9dm6//XYqKyv5wx/+0EKViyPaxGeloqIi0tLS6NmzJwEBAXTp0oWZM2dSWlrK1KlTsVgsLFmyxN1lSguzWqHsHFRU1gwT7In8/f2ZP38+eXl5LF269LIhDhAWFsZ9993H9u3b2blzJ0OGDKlddnGIA5SXl/PZZ5+1VPniII9vke/bt49Ro0ZRWFhIcHAw8fHx5Ofns3jxYo4ePcrJkycBmvSGN1Fu1ibemp/CsHueZdDoWQ2u8/y9FroPGM24WWtdXJ1rfP0dbDkEe09A5fdjvIf4w3U94fpeEO4hI68mJyezcuVK+vTpU2f+3r17+eyzz9i9ezc5OTlUV1cTEhJCv379GDRoEDfddBPh4eEAJCUlsWXLFp577jmefPJJVq5cWSfEb731VtavX+/y1yaX5tFBXlRUxNixYyksLOSRRx5h3rx5hIaGAvDMM88wZ84cfHx8sFgsJCYmurlacbaqanjjc9iVXX9ZyTlYnwmfZMFtA+HG3i4vz6mmTJnCSy+9hLe3NwDnzp1j5cqVLF26lC+//LLBbdasWQNAYGAgEydOZObMmQwYMAAvLy8eeeQRpk6dSvv27QGFeGvn0V0rM2bMIDc3l4cffpj09PTaEAdIS0ujf//+VFVV0b17d8LCwtxYqTib1Qqvbm04xC9ms8E7u2HjAZeU1SIeeOABXnnlldoQ37lzJwMHDmT69OmNhvjFysvLWblyJYMGDWL27NlUVFQAKMQN4rFBfuDAATIyMujQoQMLFixocJ1BgwYB0L9//zrzjx8/zq233kpoaCjh4eH87Gc/47vvvmvxmsV5PjsCX+Y0ff3/twcKTrdYOS1m5MiRLFu2rHb6+eefZ8iQIWRlZdm9L6vVyvPPP8+WLVvqzD9+/DgbN25sdq3Scjw2yFetWoXVamXSpEmNPjIrMDAQqBvkZ8+eJSUlhdzcXFatWsXy5cvZvHkzY8aMwWq1uqT2llB1vozys0UNfnkam62mT9xeWx3Yxp3atWvHihUraq/vTk9P59e//jXV1Y497PXCic3hw4cD1F6SGB8fz+zZs51TtLQIj+0j37BhAwApKSmNrpObmwvUDfLly5eTl5fHp59+SteuXQGIiYlh6NChrFmzhttuu63lim5Bn781j8/fmufuMlwiuwgKzti/3c7jMHagOc8eXbRoEdHR0QB8+OGHzQrbhq5OSUtL489//jPe3t488cQTrFmzxqGWvrQ8Q96y9jtx4gQA3bp1a3B5VVUVW7duBeoG+dq1axk2bFhtiAMMGTKE2NhY3nvvPYeCPCkpicLCQru28fYNZPwfD9t9rMb0TZlGr2snNLjsnadHNHv/cb16UV1Z3uz9OEOP5J8y6I5n7N7uXBX0T7qBkqJjLVCVfS736S8uLo7/+q//AmquA3/wwQcdPlZDIX6hTzwmJoY5c+bg7+/PvHnzmDhxYqP76dWrl+7+bIbIyEh27drl0LYeG+SlpaVAzZuyIRkZGRQVFREaGkqPHj1q52dlZTFhQv3AS0hIcLg1UlhYSF5enl3b+PgHOXSsxrSP7EXXvsOdus+L5RfkU3WurMX2b48rShyv47tTZyiy83flDtOnT6/99x//+MfaT5f2ulSIA8ybN48pU6Zw5ZVXMn78eKKioigoKGhwX43Nl5bnsUEeGRnJqVOn2LNnT50bHKDmDXfhY2hiYiIWi6V22alTp2rP1l8sIiKCgwcPOlyLvbx9Ax06lrt0jurcalrkgb72n8uw2WxYLBbaBfng/313hTtZrdZGgzEwMJD7778fqAneFStWOHSMy4U41FzG+L//+7889thj+Pr68sADDzR6V2dUVJRa5M3gSE5c4LFBPnz4cA4cOMDChQsZMWIEcXFxQM2lWZMnT6aoqOYknytuBHLk49K5KpiT0QLFtJBDhw+3mr7lsvPwxNtw3o5zfhaLhe4d4MiB3S1XmB1KS0sbPUk/ePDg2sbG6tWra29qs0dTQvyC5cuX89hjjwFwyy23NBrkhw8fJjjYQ+6uMozH/vlMS0vjiiuuICcnh4SEBPr160evXr1ITk4mNjaWm2++Gah/6WF4eDinT5+ut7+TJ08SERHhitKlmYL8YFCPy6/3Q8PinF9LS7hw2SzAP//5T7u3tyfEAXJycjh+/DgA11xzjVrdrZDH/kZiYmLYvHkzo0ePJiAggOzsbCIiIli2bBnr1q3j0KGaa81+GOR9+vRpsC88Kyur3q3P0nrdHA+Bvk1fPyYc+ne9/HqtwcVBvnu3fZ8g7A3xHx4nODiY3r0Nvw3WA3lskENNKK9du5azZ89y9uxZtm/fzrRp0ygtLSU7OxsvLy/69u1bZ5sxY8awZcuWOiePtm/fztGjRxk7dqyrX4I4qGMoPHgTBDQhzCPbwYMp4Ovd4mU5RefOnWv/faFB0hSOhjhQ5/xQVFSUHdWKK7SSXk3XyszMxGazERcXR1BQ3atDpk2bxgsvvMC4ceN48sknqaioIC0tjeTkZMaNG+emih0XE38TM1+/9FB/l1tuqthO8OuR8OGXNXd5Wn/wMgN8ITkWUhNrumNM8fLLL/Ppp58SEBDQ6FVZDZk5c6bDA2Bt2rQJgIqKitpuFmk92mSQ79+/H6jfrQI1Q3pu2LCBmTNncvfdd+Pj48OYMWN47rnn1DdooMh2MOVHcKYM9n0N739RcyI50BeeuN2cm38u9vrrrzu03fPPP8+wYcO45ZZb7B47Zf369RprpRUz8G3cfJcKcoCrrrqKtWs9c0jXtqpdUM0IhxuyaoLcz8fMEG+OyspKJkyYQGJiot1969K6tckm5uWCXMRTVVZWKsQ9UBtrk9S4MA6LiIgnaJMtchERT6IgFxExnIJcRMRwCnIREcMpyEVEDKcgFxExnIJcRMRwCnIREcMpyEVEDKcgFxExnIJcRMRwbXKsFRP4ecPCie6uoun8DHkogymCgoIoKSlx2v6eXfYGxaVlhAUHMfvnd9ebdoYfju0vrqMgb6UslrY3zKr8h8ViceqDjP38A/CrrMbPP4Dg4OB602I2da2IiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjgFuYiI4RTkIiKGU5CLiBhOQS4iYjg9TExEWiWbDayV7q7CPl6+NY9pdDUFuYi0StZK2LjY3VXYJ2UGePu5/rjqWhERMZyCXETEcApyERHDKchFRAynk53i8c5XQd4p+LYYzlX9Z17+KbiyHXirOSOGU5CLRzpbAZ8fgT0n4JszYLXVXV5eCc+8D77e0PUKuPYqGNAV/PQ/Qgykt614lDPlsHZvTYBXWy+/fmU1HP225uvd3fCjq2F4Qk3Ai5hCQS4ewWaD3dnw9i4oO+/YPsrOw0f74Yuv4Z7roFsHp5YoLvDF0U3M+p+UOvMC/IKJ6RjH8IGTue36X+Ht7Xmx53mvSNqcaitkbIcdx5yzv8Iz8OeP4c4kuD7OOfsU10oZcA/JvX+CDRunzhbyf7tf5X/e+y1ff3uA39y53N3lOZ2CXIxmtcJrW2Hf187dr80Gb+6EKivc2Nu5+5aW1yt6IMMH3Vs7PXboL5n6TG8+2PES96c+RfuQjm6szvl0vl6M9s4e54d4nf3vhr0nWm7/4hqBfsH07nYdNpuN/O+Ourscp1OLXIx1sAA2H7Rvm9+mQlggFJfDog+bts2bOyC2E7QLtL9GaT0Kvg/wsKAIN1fifG2iRV5UVERaWho9e/YkICCALl26MHPmTEpLS5k6dSoWi4UlS5a4u0yxQ0UlvPG5/duFBUL7oJrvTVV2vibMbbbLryutQ0VlGWdKizhd8m+OF+xn8dsPcSRvL727JBPT0fNOfHh8i3zfvn2MGjWKwsJCgoODiY+PJz8/n8WLF3P06FFOnjwJwIABA9xbqNjl04Nwqsx1x/sqF459C1dd6bpjiuNe/Xger348r868YX1v51fjX3RTRS3Lo4O8qKiIsWPHUlhYyCOPPMK8efMIDQ0F4JlnnmHOnDn4+PhgsVhITEx0c7XSVNVW2HbY9cfdclhBborR107jhsQJVFkrOV6wn4xNCyk6k4ufb0DtOvuPbeZ3K0bV27aq+jxWazUfPVPtypKbxaODfMaMGeTm5vLwww+Tnp5eZ1laWhp///vf+eKLL+jRowdhYWFuqlLslZUHp13YGr/gy5yavnV7umXEPaI79GJg3HAAknuPom+PYfxm6TCef2s6c+99A4B+sT/ivadK6mxXdCafhxYnMW7owy6vuTk8to/8wIEDZGRk0KFDBxYsWNDgOoMGDQKgf//+tfMuBH9ycjL+/v5Y3PG4D7mkzDz3HLfaWnOCVcyT0H0owwdOZtMXGWRmb2twnfNV53jy1dvp230YP/3x71xcYfN4bJCvWrUKq9XKpEmTCAkJaXCdwMCaptXFQX7kyBHeeustIiMjGTx4sEtqFfvknnTfsXPceGxpnknDH8fLy5u/fvT7Bpc//9Z0zldWMHviStcW5gQeG+QbNmwAICUlpdF1cnNzgbpBfsMNN1BQUMCaNWsYPnx4yxYpdquqhoIz7ju+O/+ISPNEd+hJSv+72XvkE/Yf21xn2TtbFrP9wFqenPIuAX5BbqrQcR4b5CdO1NzF0a1btwaXV1VVsXXrVqBukHt5eeyPxCMUlzdtMKyWcqrUfceW5rvnx3Pxsnjx14//0yrfd2QjL62bw+OT3yQyorv7imsGjz3ZWVpa8z+uvLy8weUZGRkUFRURGhpKjx49WrSWpKQkCgsLW/QYbUVIhx6kzt7c6PILN/w0JizgP9+fGN/4eo3dMFTwzb+JibmmidW2HuPv/zXBIWEUFBYQExNTb7o18vMJZPnD9l2e1P+qm/i/Zxu/4L/blX3qXI1SeDKbP75+Fw+OeZb+V93kaKm1esX14nxVw5lzOZGRkezatcuhbT02yCMjIzl16hR79uxhyJAhdZYVFBQwe/ZsABITE1v8hGZhYSF5eW46Q+dhws77Xnr59zf8XI6XV9PW+6HK8xVG/i6t1dW13/Py8upNt0YBvi3bxVFxvox5K29jSPyt3Ha9c65SKcjPp6LS9ZdUeWyQDx8+nAMHDrBw4UJGjBhBXFzN3Vw7d+5k8uTJFBUVAa65ESgyMrLFj9FW+Pj5XXJ58WUaQ2EBNSFutUJxhf37qao4TXR09GWqbH28vL1rv0dHR9ebbo38fFr2Os/N+9/iWMEX5BUdYtMXGfWWr5iVRafwrnbtM6pz52a1yB3lsUF+4TrxnJwcEhIS6N27NxUVFRw5coRRo0bRvXt3Pvroozr94y3F0Y9L0rCn1sC/zza87HLjpzwxvqYlXlwBT7xj/7FH3dCPv6bl2r+hm81/8W8Ul5QSFRlFbm5uvenWqPo8bFzccvsfMWgyIwZNduo+Dx86jPel2xotwmPP7MXExLB582ZGjx5NQEAA2dnZREREsGzZMtatW8ehQ4cAXBLk4lxd3DjmkTuPLdIYj22RA/Tp04e1a9fWm19SUkJ2djZeXl707dvXDZVJc/SKrHmUmzv01C360gp5dJA3JjMzE5vNRlxcHEFB9U+orF69GoCsrKw60927dycpKcl1hUqDBnareb7muSrXHrfnlXBlO9ceU6Qp2mSQ79+/H2i8W2XChAkNTt93332sXLmyRWuTy/P3heRY2HzItccd1su1xxNpKgV5A2waeLrVu6kPbD8G513UKu/cHvp1cc2xROylIBcjXRECt14Dq3e2/LG8LPDTIeDtsZcGtD2ffrmavYc/4Re3PsdTf7ubE99k4e8bSPuQTsy4/S9Ed+jp7hLt0iaD/MI4LGK2ob1qhpY9ZMdNsxeuD7/c9eYXG9EXYnS1ikfZ+tU7DB/0MwB+cu00knuPwmKx8O7WJSx68wH+9ItN7i3QTm0yyMUzeFlgyjBYsh7yTzdtm6Y+p/OCpB4wsp/dpYmblZSf5sE/9eVcZTkd23Whsvochd8d48eDJjPz9r+Qmb2V2RNX4uPty7V9flK7XZ+u17H6n+mX2HPrpCAXowX5wy9/DMs2On+I2eRYmHhtzR8MMUtIYHtuHvBTAv1DuXfE4+w8+BGrNsznkQkvsevgx8R3G4qPd/3hHt7Z8jxDEsa5oeLmUa+fGC8kAB4eAT9y0jN1/XzgzsFw93XqFzfZkfx99IyuGeDscO5uenau+fe2zHe5vm/9EdP+/sl88ouOMHVUww+iac30NhWP4O8DdwyGh4ZDp2Y8te/qKJgzGobFqSVuumM/DPLoa7DZbOw6+BHJves+q/PNTels+ept5j/wgZHjkatrRTxKryvh0TE1J0C3HKp5LNzlrib196npC7++F3QOd02d0rKKzuSBxUKHdjUDgh0r/JKf/ngu/8rZQdcr+xDo/5+nhq3+5yI27lvFwmnrCQls76aKm0dBLh7HywK9o2q+Kioh7xTkfAffFENlFVi8IMCnJrS7REBkO/DxdnfV4kxH8vbWdqUAhAS0Z81nS2kX3IGhCbfVzv/36VyWrX2EqIhYZv1PzdPE/Hz8eWHGdleX3CwKcvFoAb5wVaeaL2k7rosfw3XxY2qnX5xZc8PBA+kJPDt9Y+38ju1jLvkgClMoyEWkzXhpVqa7S2gROtkpImI4BbmIiOEU5CIihlOQi4gYTic7RaRV8vKFlBnO29+zy9+guLSMsOAgZk+7u960M3jVv+vfJRTkItIqWSw49UHGVks1VqqwWqrx9qs/bTJ1rYiIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZrE0FeVFREWloaPXv2JCAggC5dujBz5kxKS0uZOnUqFouFJUuWuLtMERGH+Li7gJa2b98+Ro0aRWFhIcHBwcTHx5Ofn8/ixYs5evQoJ0+eBGDAgAHuLVRExEEe3SIvKipi7NixFBYW8sgjj1BQUMCePXsoLCxk4cKFrFu3jp07d2KxWEhMTHR3uSIiDvHoIJ8xYwa5ubk8/PDDpKenExoaWrssLS2N/v37U1VVRffu3QkLC3NjpSIijvPYID9w4AAZGRl06NCBBQsWNLjOoEGDAOjfv3/tvNWrV3PHHXfQrVs3goKC6N27N3PnzqWkpMQldYuI2Mtjg3zVqlVYrVYmTZpESEhIg+sEBgYCdYM8PT0db29v5s+fzwcffMAvfvEL/vKXv5CamorVanVJ7SIi9vDYk50bNmwAICUlpdF1cnNzgbpB/t5779GxY8fa6RtvvJGOHTsyadIktmzZwg033NBCFYuIOMZjg/zEiRMAdOvWrcHlVVVVbN26Fagb5BeH+AVJSUkA5OXlOVRLUlIShYWFDm0r4gzj7/81wSFhFBQWEBMTU2+6LWjtP4PIyEh27drl0LYeG+SlpaUAlJeXN7g8IyODoqIiQkND6dGjxyX3tXHjRgD69OnjUC2FhYUO/xEQcQZrdXXt97y8vHrTbYEn/ww8NsgjIyM5deoUe/bsYciQIXWWFRQUMHv2bAASExOxWCyN7icvL4/HH3+c1NRUh681j4yMdGg7EWfx8vau/R4dHV1vui1o7T+D5uSExwb58OHDOXDgAAsXLmTEiBHExcUBsHPnTiZPnkxRURFw6RuBSkpKGDduHH5+frz88ssO1+LoxyURZ5n/4t8oLiklKjKK3NzcetNtgSf/DDz2qpW0tDSuuOIKcnJySEhIoF+/fvTq1Yvk5GRiY2O5+eabgbr94xcrLy9n7NixHD9+nI8//pioqChXli8i0mQeG+QxMTFs3ryZ0aNHExAQQHZ2NhERESxbtox169Zx6NAhoOEgr6ys5M4772TXrl188MEHxMfHu7p8EZEm89iuFag5Obl27dp680tKSsjOzsbLy4u+ffvWWXbh2vNPPvmE999/n+TkZFeVKyLiEI8O8sZkZmZis9mIi4sjKCiozrKHHnqIN998k0cffZSgoCA+//zz2mVXXXVVg5cnioi4k8d2rVzK/v37gYa7VT744AMAnn76aYYMGVLna926dS6tU0SkKdpki/xSQZ6dne3iakREmkctchERw7XJFvmFcVhERDxBm2yRi4h4EgW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOQiIoZTkIuIGE5BLiJiOAW5iIjhFOStwGuvvcagQYMIDw8nMDCQPn36sGjRImw2m7tLE2nU+++/z4ABA/D396d79+4sWrTI3SW1WT7uLkCgU6dOPP7441x99dX4+/uzefNmfvnLX+Lt7c3MmTPdXZ5IPbt27WLcuHHMmjWLVatWsX37dqZPn05QUBDTp093d3ltjoK8FRg5cmSd6djYWN599102bdqkIJdWadGiRQwePJgFCxYA0KdPHzIzM3n66acV5G6grpVWxmazsWPHDrZu3UpKSoq7yxFp0NatW0lNTa0zLzU1lRMnTpCbm+umqtoutchbiTNnzhAdHc358+exWq3MmzePGTNmuLssMYzVauXoiXx+eHalqrq69vuh47n1pi8W3i6EjhHtL3mcgoICIiMj68y7MF1QUEBMTIzjL0LspiBvJUJDQ9m3bx9lZWVs27aN//7v/6Zz585MnTrV3aWJQby8vMg6coLP9mQ2uLysvIKX//F+o9O+vj7MvP+OFq9TnEtB3kp4eXnRs2dPABITEzl16hRz585VkIvdRt10LUeyc/n3yTN2bzvm5uvoEN7usutFRUVRWFhYZ94333xTu0xcS33krZTVaqWiosLdZYiB/Hx9uGtMCl4Wi13bXR3bheT+fZq07vXXX89HH31UZ96HH35It27d1K3iBmqRtwLz5s3jRz/6EbGxsVRWVvLpp5+ycOFC7r//fneXJobqEtWJm4cOZP3W3U1aPyjQnztH3YilieH/m9/8hqFDhzJ37lwmT57M9u3beeGFF3juueeaU7Y4SEHeChQXFzN9+nTy8vIICAggNjaWBQsW6DIuaZaUIddw8NjX5BT8+7Lr3j7yBkJDgpq878GDB/Puu+/yu9/9jvT0dCIjI3nqqaf0nnUTBXkr8Nxzz6klI07n7e3FXWNSWPzKW1RWVTe63sC+veh7dQ+79z969GhGjx7dnBLFSdRHbpicgm8pqzjn7jLEEB0j2vOTlOsaXd4+LIRbh1/vwoqkJahFbpCq6mpef+f/qDh3nql3/YSu0Ve6uyQxwHXXxHPgyIl614tbgAmjbyLA3889hblQZmYmazJWcmD/Xs6fK+fF+WmERVxJv8HDSLxmsLvLaza1yH+gurqa1157jVtuuYWOHTvi7+9P165dSU1N5aWXXqK6uvGPqC1t9/6DnDlbip+fL1GdrnBbHWIWi8XCnaNuJDDAv878YYMTuaprZzdV5RqlpaXceeed9O3bl+2b11N8+jsqysvIz8/nX1/t5c1XXmDxU4/yr3/9y92lNovFpiH2ahUXF3PbbbexceNGADp37kx0dDT5+fnk5+djs9k4deoU7du3d3ltVdXVPLvsDc6cLWXsj4dyfVJfl9cgZvvywFH+vuYTAK7sEM7D943H18dzP5SXl5czYsQItm7detl1IyIi2LJlC336NO3yy9ZGLfKLTJ06lY0bNxITE8OGDRvIy8tjx44d5ObmUlBQwFNPPYWvr69barvQGg8NCSK5f2+31CBmS+xzFQPie+Lt5cXEMSkeHeIAc+bMaVKIA5w8eZLx48djtVpbuKqWoRb593bv3k1SUhI+Pj7s3buXvn2d1+J94a9vc7akvBl7sHG2tBybzUaAvx9+bvpjIuaz2WxUVlV5/HuooryMhXN/xfnz9l0Y8LNfzObqhP4tVNWlhYYE8qv7bndoW8/+k2yHd999F6i5pMqZIQ5wtqSc4pJSp+yr4tx5Ks6dd8q+pO3y9PfQ7m0b7Q5xgK0bPySqW88WqKhlKci/l5WVBcCQIUOcvu/QkMBmbK3WuIi9vvsmz6Htvsn/mrCQYCdX0zTNyQkF+feKi4sBaNfu8gMG2cvRj0sA2/cd4J2PNhMaEkTatLvx9dWvTORy9v3z/7F3u/3bWWxWfvfQJOcX1MKUCt8LCwsDasYFdzbH+8hrWuMAlZVVPLs8w7mFiXio43mXH5agIV4+fsx/8W9OrqZp1EfuBAkJCbz99tt89tlnTt+3M/rI1Tcu0nRdYnuza9smu7frEZfgtPNZrqQg/9748eP5wx/+wPvvv09WVhbx8fFO27djfV/qGxdx1DWDh/DJ2gyKT5+ya7thKSON7CPX5YcXmThxIv/4xz/o2rUrr776KjfeeGPtsm+++YaXX36ZGTNmEBzc8r9o9Y2LNM/SpUt56KGHmrz+2LFjWbNmTQtW1HIU5BcpLi5m3LhxbNq0CYDo6Gg6d+5MQUEBeXl5Lruzs6q6mvTlGZwuLtFdnCIOstlszJo1i0WLFl123eTkZNavX09oaKgLKnM+3dl5kbCwMNavX8+KFSu46aabKCsr44svvsDLy4uRI0eyYsUKl/yid+8/xOniEt3FKdIMFouF9PR0lixZQufODY8pExgYyPTp09mwYYOxIQ5qkbdKezMP88GmHdx4bX+1xkWcoLKykvfee49169Zx+vRpgoODGThwIPfddx/h4eHuLq/ZFOStVGVVFRYs+Ph4u7sUEWnlFOQiIoZTH7mIiOEU5CIihlOQi4gYTkEuIh7l8OHDDB06lLi4OAYPHkxmZuYl19+wYQPJycnEx8eTkJBAWlqacQ+YUJCLiEf5+c9/zrRp0zh06BBz5sxhypQpl1w/PDycN954g6ysLHbv3s22bdt49dVXXVOskyjIRcRjfPvtt+zatYt7770XgDvuuIOcnBwOHjxITEwMx44dAyA9PZ3U1FSsVivXXHMNsbGxAAQEBDBgwACys7Pd9RIcoiAXEY+Rk5NDVFQUPt8/j9RisdC1a1fy8vJ49tlnueuuu9i0aRMvvvgir732Gl5edSOwsLCQ1atXM2bMGHeU7zCNxCQibcI999zDxo0bGTlyJJ988gkdO3ass7y4uJixY8eSlpZGUlKSm6p0jFrkIuIxunTpQkFBAVVVVUDNwFlff/01Xbt2paqqiq+++oqIiAjy8uo+Cu7s2bOkpqYybtw4fvvb37qj9GZRkIuIx+jUqRMDBw7k9ddfB+Ctt94iJiaGnj178uijj3L11VezefNmZs2axZEjRwAoKSkhNTWV1NRUHnvsMXeW7zDdoi8iHuXgwYNMmTKF7777jrCwMF555RVOnDjBo48+yo4dOwgKCuLNN99kwYIFbNu2jT/96U888cQTJCQk1O5jwoQJzJ07142vwj4KchERw6lrRUTEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAynIBcRMZyCXETEcApyERHDKchFRAz3/wFdUqAED/bVnAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", - "from qiskit.dagcircuit import DAGCircuit\n", - "import numpy as np\n", - "q = QuantumRegister(3, 'q')\n", - "c = ClassicalRegister(3, 'c')\n", - "circ = QuantumCircuit(q, c)\n", - "circ.h(q[0])\n", - "circ.cx(q[0], q[1])\n", - "circ.measure(q[0], c[0])\n", - "circ.rz(np.pi/2, q[1]).c_if(c, 2)\n", - "circ.draw(output='mpl')" + "# Add in another pass as example to decompose to backend basis gates\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We can then view this circuit's DAG by using the `qiskit.tools.visualization.dag_drawer()` function. You'll notice there are three kinds of graph nodes: qubit/clbit nodes (green), operation nodes (blue), and output nodes (red). Each edge indicates data flow (or dependency) between two nodes." + "`PassManagers` can also include control flow instructions to programatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController.md) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController.md). (*this need more explanation*)" ] }, { - "cell_type": "code", - "execution_count": 3, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Could not save to JPEG for display", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[39m=\u001b[39m RAWMODE[im\u001b[39m.\u001b[39;49mmode]\n\u001b[1;32m 640\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", - "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave(b, image_format, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m save_handler(\u001b[39mself\u001b[39;49m, fp, filename)\n\u001b[1;32m 2414\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m:\n", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcannot write mode \u001b[39m\u001b[39m{\u001b[39;00mim\u001b[39m.\u001b[39mmode\u001b[39m}\u001b[39;00m\u001b[39m as JPEG\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mOSError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[39m=\u001b[39m im\u001b[39m.\u001b[39mencoderinfo\n", - "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib/python3.11/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[39m=\u001b[39m get_real_method(obj, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[39mif\u001b[39;00m method \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[39mreturn\u001b[39;00m method()\n\u001b[1;32m 345\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[39melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_repr_jpeg_\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[39m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_repr_image(\u001b[39m\"\u001b[39;49m\u001b[39mJPEG\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", - "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mCould not save to \u001b[39m\u001b[39m{\u001b[39;00mimage_format\u001b[39m}\u001b[39;00m\u001b[39m for display\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[39mreturn\u001b[39;00m b\u001b[39m.\u001b[39mgetvalue()\n", - "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "from qiskit.converters import circuit_to_dag\n", - "from qiskit.tools.visualization import dag_drawer\n", - "dag = circuit_to_dag(circ)\n", - "dag_drawer(dag)" + "## Building & Using Custom Plugins\n", + "\n", + "In this section we'll discuss installing and utilizing custom plugins, as well as writing your own from a `PassManager` object...." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [] } ], From f5bc6442e0012c8b2c03b08da7d5fa1afd1c7ed1 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 17:35:47 -0500 Subject: [PATCH 36/48] updated gitignore --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 2d11cd3c41e..7776c75940f 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ node_modules tsconfig.tsbuildinfo .out/ +poetry.lock +pyproject.toml From 793923ec16ae108a9ac3e6e2bce4e712d5ae302a Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 17:36:36 -0500 Subject: [PATCH 37/48] Updated gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 2d11cd3c41e..16957ec7613 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,6 @@ node_modules tsconfig.tsbuildinfo .out/ +poetry.lock +.gitignore +pyproject.toml From 6866cfef57a2fe4c952d0e40eb01125cb7d2c061 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 17:38:45 -0500 Subject: [PATCH 38/48] Update gitignore --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 2d11cd3c41e..7776c75940f 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ node_modules tsconfig.tsbuildinfo .out/ +poetry.lock +pyproject.toml From 44051c5b0b8484841a80706973562b889520cfb2 Mon Sep 17 00:00:00 2001 From: kaelynj Date: Fri, 10 Nov 2023 18:06:20 -0500 Subject: [PATCH 39/48] update outline --- docs/transpile/customized-passmanagers.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 38da1a2a382..ecd4fd34804 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -294,7 +294,9 @@ "source": [ "## Building & Using Custom Plugins\n", "\n", - "In this section we'll discuss installing and utilizing custom plugins, as well as writing your own from a `PassManager` object...." + "In this section we'll discuss installing and utilizing custom plugins, as well as writing your own from a `PassManager` object....\n", + "\n", + "Look to the page on writing [transpiler plugins](https://qiskit.org/documentation/apidoc/transpiler_plugins.html#plugin-api)" ] }, { From c6bac440d0d80b9f117b3aa73d14850a3617a166 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 14:59:21 -0500 Subject: [PATCH 40/48] file cleanup --- docs/transpile/_toc.json | 4 +- docs/transpile/customized-passmanagers.ipynb | 2 +- docs/transpile/index.mdx | 42 ---- docs/transpile/passmanagers.ipynb | 221 ------------------- 4 files changed, 3 insertions(+), 266 deletions(-) delete mode 100644 docs/transpile/index.mdx delete mode 100644 docs/transpile/passmanagers.ipynb diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index ec40a3acc2a..db6ed01cc4d 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -6,8 +6,8 @@ "url": "/transpile" }, { - "title": "Preset pass managers", - "url": "/transpile/passmanagers" + "title": "Transpiler stages", + "url": "/transpile/transpiler-stages" }, { "title": "Customizing Transpilation", diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index ecd4fd34804..5c43c943738 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -6,7 +6,7 @@ "source": [ "# Customizing a transpilation pipeline\n", "\n", - "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and installing them as plugins. Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" + "In the [Transpiler stages](transpiler-stages) topic we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassManager` objects, writing your own bespoke transpiler passes, and installing them as plugins. Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" ] }, { diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx deleted file mode 100644 index a38febb7ceb..00000000000 --- a/docs/transpile/index.mdx +++ /dev/null @@ -1,42 +0,0 @@ ---- -title: Introduction to the transpiler -description: Introduction to the transpiler - ---- - - -# Introduction to the transpiler - -Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device and optimize the circuit instructions for execution on present-day noisy quantum systems. This documentation covers the tooling and workflows for transpilation available to Qiskit users. If you're using primitives and are only interested in the default transpilation options, look to the section [Configure runtime compilation for Qiskit Runtime.](../run/configure-runtime-compilation) - -A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, allowing you to greatly reduce the depth and complexity of your quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by `PassManager` and `StagedPassManager` objects. The `StagedPassManager` will orchestrate the execution one or more `PassMangers` and determine the order in which they are executed, while the `PassManger` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Passes` as the individual musicians. In this way, you have the power to compose hardware efficient quantum circuits and allow you to execute utility scale work while keeping noise manageable. - - -## Transpiler stages -Qiskit utilizes a set of six fundamental stages in the prebuilt transpiler pipeline: - -1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this will just validate the circuit instructions and translate multi-qubit gates into 1 and 2 qubit gates) -1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend. -1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map. -1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions. -1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth). -1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions. - - If you decide to customize your own transpilation workflow, we suggest using these stages as a guideline during development. - - - -## Default transpilation -The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`](../api/qiskit/compiler#compilation-routines) function. This will generate and run one of the preset `StagedPassManager`s based on, among other options, an `optimization_level` flag which can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. - -- `optimization_level=0`: Maps the circuit to the backend, with no explicit optimization. -- `optimization_level=1`: Maps the circuit, but also does some lightweight optimizations by collapsing adjacent gates. -- `optimization_level=2`: Medium-weight optimization, including a noise-adaptive layout and a gate-cancellation procedure based on gate commutation relationships. -- `optimization_level=3`: Heavy-weight optimization, which in addition to previous steps, resynthesizes two-qubit blocks of gates in the circuit. - -If you'd like to read more about the preset pass managers or the transpiler stages, look to the section on [Transpiler stages and preset PassManagers](passmanagers). - - -## Customizing passes -For more advanced users, you can customize your own set of `PassManager` and `StagedPassManager` objects and determine the ordering in which each stage is run. This can dramatically change the final output circuit. In fact, oftentimes a bespoke approach to transpiling a quantum algorithm produces more efficient error suppression than the default approach. This involves rewriting quantum circuits to match hardware constraints and suppressing the effects of noise. The flow of logic for this tool chain is quite customizable and need not be linear. The transpilation process can even prepare iterative loops, conditional branches, and other complex behaviors. A good starting place when developing a set of custom passes is to examine the default sequence of transformations. - diff --git a/docs/transpile/passmanagers.ipynb b/docs/transpile/passmanagers.ipynb deleted file mode 100644 index 6fdc3d99e43..00000000000 --- a/docs/transpile/passmanagers.ipynb +++ /dev/null @@ -1,221 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " # Transpiler stages and preset pass managers\n", - "\n", - "Qiskit includes functions to build preset `PassManager` objects. These are objects that manage a set of different `Passes`, which can include things like transforming the operations in your quantum circuit, optimizing the selection of qubits to be used on the target backend, and other optimizations that improve the overall efficiency of your circuit and suppress the effects of noise. This page details the default passes when running `qiskit.compiler.transpile()` or when setting the `optimization_level` of a Runtime object.\n", - "\n", - "\n", - "When the `transpile()` function is called, a preset `StagedPassManager` object is created and then executed. The four different preset pass managers range from very light to heavy optimization, which is specified by the `optimization_level` argument that can range from 0 to 3. Higher optimization levels take more time and computational effort but may yield more optimal circuits. Optimization level 0 is intended for device characterization experiments and, as such, only maps the input circuit to the constraints of the target backend, without performing any optimizations. Optimization level 3 spends the most effort optimizing the circuit. However, as many of the optimization techniques in the transpiler are heuristic-based, spending more computational effort does not always result in an improvement in the quality of the output circuit. For specific details on the preset pass managers, look to the [API reference section](../api/qiskit/transpiler_preset).\n", - "\n", - "The four stages of the preset pass managers provide a useful framework for optimizing your quantum algorithms. Recall that these stages are:\n", - "\n", - "\n", - "1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend. This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates.\n", - "1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend.\n", - "1. `routing` - This pass runs after a layout has been applied and injects gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map.\n", - "1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions.\n", - "1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth).\n", - "1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions.\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Init stage\n", - "\n", - "This first stage does very little by default and is primarily useful if you want to include your own initial optimizations. Because most layout and routing algorithms are only designed to work with single- and two-qubit gates, this stage is also used to translate any gates that operate on more than two qubits into gates that only operate on one or two qubits.\n", - "\n", - "For more information about implementing your own initial optimizations for this stage, see the section on plugins and customizing pass managers." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Layout stage\n", - "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. To execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device is necesary. This mapping is stored as a `Layout` object.\n", - "\n", - "\n", - "![Qubit mapping](/images/transpile/layout-mapping.png)\n", - "\n", - "The choice of mapping is extremely important for minimizing the number of SWAP operations needed to map the input circuit onto the device topology and ensure the most well-calibrated qubits are used. Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves two steps: first, try to find a \"perfect\" layout (a layout that does not require any SWAP operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are two `Passes` typically used for this first step:\n", - "\n", - "- `TrivialLayout`: Naively maps each virtual qubit to the same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]). This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout. If it fails, `VF2Layout` is tried next.\n", - "- `VF2Layout`: This is an `AnalysisPass` that selects an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm. If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n", - "\n", - "Then for the heuristic stage, two passes are used by default:\n", - "\n", - "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit. (Used for optimization level 1 if there are control flow operations (such as IfElseOp) present in the circuit).\n", - "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm. This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass. For more details on this algorithm, refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Routing stage\n", - "\n", - "In order to implement a two-qubit gate between qubits that are not directly connected on a quantum device, one or more SWAP gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map. Each SWAP gate represents an expensive and noisy operation to perform. Thus, finding the minimum number of SWAP gates needed to map a circuit onto a given device is an important step in the whole transpilation process. For efficiency, this stage is typically computed alongside the Layout stage by default, but they are logically distinct from one another. The *Layout* stage selects the hardware qubits to be used, while the *Routing* stage inserts the appropriate amount of SWAP gates in order to execute the circuits using the selected layout.\n", - "\n", - "However this may come as no surprise that there's no free lunch here and that finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, SWAP mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n", - "\n", - "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit. This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Translation stage\n", - "\n", - "When writing a quantum circuit, you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions. However, most quantum devices only natively support a handful of quantum gate and non-gate operations. This stage of the preset `PassManagers` translates (or *unrolls*) the gates specified in a circuit to the native basis gates of a specified backend. This is an important step, as it allows the circuit to be executed by the backend, but typically leads to an increase in the depth and number of gates.\n", - "\n", - "There two special cases which are especially important to highlight, and which help illustrate what this stage does:\n", - "\n", - "1. If a SWAP gate is not a native gate to the target backend, this requires three CNOT gates:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['rz', 'sx', 'x', 'ecr', 'measure', 'delay']\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAATEAAACuCAYAAABeIjpKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAUdklEQVR4nO3dfXBU133G8e+uAEkgCSSELUAyEiCweJFwwJiXxDEEWjOAY6chdUOJ2/F4+sZAJx6rM0mn47TpuDSeeAY7aUzrDjNpQ5SY2KaQxIkjbF5sg7DAxpYwWCDQSlpgkUBISIC02z+OZSOQ0O5yd++e5fnMMJi9bz9pr5977rnn3usJhUIhREQs5XW7ABGRW6EQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqQ9wuQCRegiHo7gGvB1K84PG4XZE4QSEmSev0BfigAXwt0NACLR2fTxs2BPKzIT8HJt0B08fDkBT3apXoeUKhUMjtIkScEgzB4QbYcxSOnQ5/ucw0mD8ZFk6Bkemxq0+cpxCTpHGuHX7+bmThdb20ofDIbJg7UaebtlCISVLYfxxeroIr3c6sb9o4+PMFMDzVmfVJ7CjExHo7a+G1aufXO24U/O1XICPN+XWLczTEQqy252hsAgyg6Tz8pBK6rsZm/eIMhZhYy9cCvzoQ4220wivvxXYbcms0xEKs1N0DP3vHXI2MxLcfhKx0aOuEH/42vGX21UFZAUwbH3mdEntJ3xILBAKUl5czefJk0tLSKCgoYP369XR0dPD444/j8Xh44YUX3C4z5i50Qm2TGTd17DRc7XG7olvz1hFzuheprHQYNdz8HYlf7DfBabPTF+CjRvjQB6fORX4ASFRJ3RI7dOgQy5Ytw+/3M2LECKZNm0ZTUxMbN26krq6OlpYWAGbNmuVuoTFUdxp2HTVjp67daUekwn0T4UtTIXuEe/VFoycIu4/Gd5vnL5kDwBcK47vdWxUMwsGTsOcYnDjbd9qYTFhYDPMmm6EltkrallggEGDlypX4/X6efPJJmpubqa6uxu/3s2HDBnbs2EFVVRUej4fS0lK3y42J338Iz78B75+68ajbcRkqa+Hffw3Hz7hTX7RqGk2oxNueOAfnrbraA5v3wE/fvjHAAM5ehFerYePv3Pl9OiVpQ2zdunX4fD7Wrl3Ls88+S2Zm5mfTysvLKSsro7u7m8LCQrKyslysNDbeOgI73h98vs4r8OJOaGqNfU1OOXDCne0eP2sG1NogGIL/edu0HgfTexX20pWYlxUTSRlitbW1VFRUkJubyzPPPNPvPLNnzwagrKysz+cnTpzgoYceIjMzk+zsbL71rW9x7ty5mNfspPYu2HYw/Pkvd5sjsi1Ouvh1NFiyKxxpMi3wcPkvwK4jsasnlpIyxLZs2UIwGGT16tVkZGT0O096uunZvTbELl68yKJFi/D5fGzZsoVNmzaxe/duVqxYQTAYjEvtTthXZ/qNInHUD6fbYlOPky52uXvq09Di3rYjsfdY5Mu880nk+00iSMqO/crKSgAWLVo04Dw+nw/oG2KbNm2isbGRXbt2cddddwGQn5/PggUL2LZtGw8//HDsinbQ/uPRLXfgOCyf5WgpjvOfd3n7F9zdfjgudpl+w0hd6DQHs5JxztcUS0l521FBQQE+n4+DBw/2e+Wxu7ubsWPHEggEqKurY+LEicDnobdz584+80+aNIkHHniAl156Kap65syZg9/vj2rZaHz1n48wNLX/FujNnKzeSlXF+hhU5JyxJUtY+Beb+53WOwbsZrLSwOs1V+3augaeb6BxZGfq3mbXpm+EX7ALRo6dxtK//11Uy763tZwT+3/mcEWDy8vL48CB6EYuJ2VLrKPDPDiqs7Oz3+kVFRUEAgEyMzMpKir67POamhpWrVp1w/zTp0+npqYm6nr8fj+NjVEcGqMU7anvpY6OuNYZjWFjAgNO6x0DFg6vN/x5r3W5qyvhf0eXU0ZHvWxra0vC/3zXS8oQy8vLo7W1lerqaubPn99nWnNzM0899RQApaWleK553kprayujRo26YX05OTl8/PHHt1RPPHW1NZOaHsUV16vnGT8+sYelj8wcuKnV1v8xq49IWmL9SfH0JPzvaFhaiFCwB4838qc8pno6Xfn5buX/kaQMsSVLllBbW8uGDRtYunQpU6ZMAaCqqoo1a9YQCJijebwGuUbbTI5WZU1kVyd7/fS5ddyRtc75ghzU3gX/uLX/aeHcRvT0I6YF1tYFT78S+fbXfH0pv/hXX+QLxtl/vWVG5kdiZDrsf+N/SbHscp9l5YanvLyc0aNH09DQwPTp05k5cybFxcXMnTuXiRMnsnjxYuDG4RXZ2dmcP3/+hvW1tLSQk5MTj9Idcd8kGBLhNzs1D+6wYLhcRlp0p4FOKYj+TC2uFhZHvsyCYqwLMEjSEMvPz2f37t0sX76ctLQ06uvrycnJ4cUXX2THjh0cPWqGXl8fYiUlJf32fdXU1FBSUhKX2p0wIhW++oXw508bCg/Pjl09TpuQ696277LkWDZ1LNwzIfz5x42CL98ds3JiKilPJ8EE0vbt22/4vL29nfr6erxeLzNmzOgzbcWKFXznO9/B5/ORn58PwL59+6irq+MHP/hBXOp2ypemmttOBjutHJEKTzwAY0fFoypn3FsU2UBOp0y6A3Iiv+jrCq8HVs+HUAgODfK7ys+GJxbZe/9kUg6xuJl9+/Yxb948pk6dypEjfYcot7W1MXPmTHJzc/ne975HV1cX5eXljBkzhnfeeQev176G64mzsPtjeL+h70DGjDSYP8m8GMPN07NoBIPwL69BaxSDXnv7xM5firxP7LEvRta6SQTBEHxwytwA/sl17x7IG2lOO+dOglSLmzMWlx6dw4cPAzeeSgJkZWVRWVnJ+vXrefTRRxkyZAgrVqzgueeeszLAAIrGmD8Xu+Df/g86rsCIYfD0w/a+oszrhfvvjt0TXfuTPRxKC+K3Pad4PTBrgvlztg2ee93cI5mRCv+wPDlehqIQu86kSZP6PQ21XWba56E1JMXeAOt1/1R4r9483TUe/nSenZ3e1xqTBUM//d6T6eXBln8tkRssxMQOKV74ZhTB0tZpTiXDGVPWa/5kuHtsZNuR+LntWmK991WK/cZlw9fvhYp94S8T7iOpexXkRHalV+LvtmuJSXKZP9m87DYW8rPhryy+ane7uO1aYpJ8vny3GSryy/3m2WhOmJFvhiikD3NmfRI7CjFJCnOKzDiun78LH9/CA0OGD4OvzYHZhcnT8Z3sFGKSNLJHwF8vNm/02XMUjjSHv+zIdHPbzYJicyVX7KEQk6Ti8ZhTwRn55kUYhxvM01h9LRBoNyPYexXfCfk5pgVXMs7+IRS3K4WYJK0xmbB4Wt/P/mmreYLFyHT4uyXu1CXO0rFHbivq50o+CjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErDbE7QIkdoJBON0GDS3Q2AqXrpjPL12B33wABTmQnwMj08HjcbdWiY0r3dB0Hnwt0HTdPlBZY77//BwYPszVMm+JQiwJtXbA28fgnTpo77px+tUeeP3w5//Oz4YvToEvFMIw7RFJoeEc7D4KB0+a7/t6V3tg20Hz3x6gZJzZB+4eB17LDmjaZZPIpSuwrRr2HYdQKPzlfK3w833w2kFYXgYLiu3bkcU40wYV+6DuTPjLhICaJvNnTCZ8Yy4U58WsRMcpxJJETaPZeS90Rr+OzivwchW8fwoenQejM5yrT2IrGIJdR2DH+/23vMJ19iL86A+wsBgeugdShzpXY6yoYz8JvHkENr15awF2rWOn4Ye/Nackkvh6gvDTvfBq9a0F2LX2HoPn3+i/OyLRKMQs9+YRePU959fbcdkckX0tzq9bnBP8NMAOnnR+3b4Wsw9cuuz8up2kELPYR42xCbBeXVdh004TaJKYfv0BHDoVu/U3n4fNeyLrY4039YlZ6tJl0wcWiW8/CFnp0NZpThfD0dYFvzoAaxZGXqPEVn0A/lAT2TLR7ANH/eZq98IpkdcYD7dFSywQCFBeXs7kyZNJS0ujoKCA9evX09HRweOPP47H4+GFF15wu8yIvFptdsRIZKXDqOHm70i8Vw8fNES2jMRWdw9seSfyFlK0+8C2g9DSHtky8ZL0LbFDhw6xbNky/H4/I0aMYNq0aTQ1NbFx40bq6upoaTGdPrNmzXK30Aica4eq4/Hd5uuHYWa+nYNiAxdNR/Xhhs8vfnRcNsE8fTykWHgoP3TKDGSOl8vdpv/1a3Pit81wWfj1hS8QCLBy5Ur8fj9PPvkkzc3NVFdX4/f72bBhAzt27KCqqgqPx0Npaanb5Ybt7WNmbE88NbbCScuuVnb3wJZ34fvbYGctBK5pSXQH4b93wfdfg1OW/VwAe4/Gf5v7j5swSzRJHWLr1q3D5/Oxdu1ann32WTIzMz+bVl5eTllZGd3d3RQWFpKVleVipeHrCcK7de5se+8xd7YbjZ5PQ2rfIL+r1kvw/O/hZCA+dTmhqRVOuFBv11U4WB//7Q4maUOstraWiooKcnNzeeaZZ/qdZ/bs2QCUlZV99llv6M2dO5fU1FQ8CXb+1HzevauFn5x2Z7vReOMjMwI9HFd74KW3zH2GNjjm4veQiPtA0obYli1bCAaDrF69moyM/oeep6eb3s1rQ+yTTz5h69at5OXlce+998al1kg0uDhuq7XDjsGP3T2Rn261dcV2qIKT3By75+b+N5CkDbHKykoAFi1aNOA8Pp8P6Bti999/P83NzWzbto0lS5bEtsgoNLq8E/la3d1+OA77TChFao8L/UzRcPM7ONOWeP1iSXt18uRJM4R5woQJ/U7v7u5m7969QN8Q83qdz/U5c+bg9/sdWdd9q/+DgtKV/U7rHQM0kKy0z/9++pGbb2egcUR/+cRaGg69Gl6xLpm57LtMfeBvIl6u/kw3+fmFzhfksOXffY/0rDv7nebUPjDQ9x8CZpTdS+eF5vALDkNeXh4HDhyIatmkDbGOjg4AOjv7H0xVUVFBIBAgMzOToqKimNbi9/tpbGx0ZF2Xb9Jx0zsGaDBeb3jz9edCW7tjP0usFF+J7gZCb8oQ/GcC9FxN8FsUPCkDTorHPnDm7DnazibOPpC0IZaXl0drayvV1dXMnz+/z7Tm5maeeuopAEpLS2PeeZ+X59xzTVKHDtxSHGzwa1aa2XmDwcFPtwZaV1bmcMaPHz9Ile4aNiQY1XI9V7vIuyPX4WpiIDjwgcypfeBm6xmTm0PmsCuDFBmZW/l/JGlDbMmSJdTW1rJhwwaWLl3KlCnmnomqqirWrFlDIGCuUcdjkGu0zeT+bKuGytr+pw12G8nTj5ijb1sXPP1KdNvfsvnHFI35cXQLx8nxM7Dx95Evd8/ENJ7/tJ80kT33+sBDQmK9DwzxwscfHkioAcIJVIqzysvLGT16NA0NDUyfPp2ZM2dSXFzM3LlzmThxIosXLwb69ofZID/HvW17PDA+273th6toDIwbFflyC4sdLyUmClzcB8ZlJ94dDglWjnPy8/PZvXs3y5cvJy0tjfr6enJycnjxxRfZsWMHR4+aS1G2hVjBaPe2nZdlx+OrPR74oxmRLVOYa8/TTN0MMTe3PRALdsnolZSUsH379hs+b29vp76+Hq/Xy4wZEe7tLsvNgDuz4nvfXK9pid0V1sesCbCiHbYfGnzeO7Pg8S/b80ju3ufgB114PM70BNwHkjrEBvLRRx8RCoWYMmUKw4ffeInm5ZdfBqCmpqbPvwsLC5kzx907YD0e80iUXznXzRbedjHP3rfJkumm/+c3H5ib5q+X4oV77jI3NQ9PjX990RqZDqUF8R+cOzrDBGiiuS1D7PBh86qfgU4lV61a1e+/H3vsMTZv3hzT2sJxb5FpYcTzNpmScXY+c39OkXmL05EmMwj20mUYkgJjR8F9kyAzze0Ko7NwSvxDbMHkxGytKsT6EUrkx1gC6cPgwZmfv3Ir1lK8sPKe+GwrFrwecyps0+nwYCbfYU7tPorTcK3cDPji1PhsK1JJ27F/M4OFmA0euBsmxGlI04MzTctFEofHA9+4zxzQ4uHP5kFqgjZ5bssQq6ysJBQKsXz5crdLiZrXC9+cB2kRvFKrrRPOX4rsibBFY2DxtMjrk9gbmQ6rInxGQTT7wKISmNT/XU4JwRNK9HMnuanjZ+AnlRDlnTY3NS4b1n7Frk7v29FbR+CVGL0wZk4RfHN+YvaF9VKIJYETZ+E/3zRvAHdKUS488YACzBZ7j8HWKmeHXSwshj+ZY1r9iUwhliQudMIv98OHt3jXTIoX/ngmfGVa4o3Mlps7dc68PKT5wq2tJyMVVs2FsrucqSvWFGJJJBSC6np4/UPz3KdIeDBjgFbOMqeRYqfuHvMat90fQ3uED+MYmmJOH5eXQYZFQ08UYkkoFDKPEd57DD45c/OnsY7JhBn55tQhN3Pg+cQu3T3w/inzPoZT5wZ+kGGK19xnOrsQ5k60s/tAIZbkQiFzqulrMc/m7wmawZ45I8zN5JFc3RQ7BUNwtg2azsPlq+bBhkNTzO1WY0eZ/cFmCjERsZq6bkXEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKymEBMRqynERMRqCjERsZpCTESsphATEaspxETEagoxEbGaQkxErKYQExGrKcRExGoKMRGxmkJMRKz2/x/CEYiM8IIdAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qiskit.providers.fake_provider import FakeSherbrooke\n", - "from qiskit import QuantumCircuit\n", - "\n", - "backend = FakeSherbrooke()\n", - "print(backend.operation_names)\n", - "qc = QuantumCircuit(2)\n", - "qc.swap(0, 1)\n", - "qc.decompose().draw('mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices. However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices. Thus, minimizing the number of SWAP gates in a circuit is a primary goal in the process of transpilation.\n", - "\n", - "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate. Given that our basis gate set includes only single- and two-qubit gates, this operation must be decomposed. However, it is quite costly:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['rz', 'sx', 'x', 'ecr', 'measure', 'delay']\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "qc = QuantumCircuit(3)\n", - "qc.ccx(0, 1, 2)\n", - "qc.decompose().draw('mpl')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates and a handful of single-qubit gates. From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affected by noise." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Optimization stage\n", - "\n", - "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages. Fortunately, there are many routines for optimizing circuits by either combining or eliminating gates. In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology. In other cases, not much can be done, and the computation may be difficult to perform on noisy devices. This stage is where the various optimization levels begin to differ.\n", - "\n", - "- For `optimization_level=1`, this stage prepares the [`Optimize1qGatesDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition) and [`CXCancellation`](../api/qiskit/qiskit.transpiler.passes.CXCancellation), which combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n", - "- For `optimization_level=2`, this stage uses the [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation) pass instead of `CXCancellation`, which removes redundant gates by exploiting commutation relations.\n", - "- For `optimization_level=3`, this stage prepares the following passes:\n", - " - [`Collect2qBlocks`](../api/qiskit/qiskit.transpiler.passes.Collect2qBlocks)\n", - " - [`ConsolidateBlocks`](../api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks)\n", - " - [`UnitarySynthesis`](../api/qiskit/qiskit.transpiler.passes.UnitarySynthesis)\n", - " - [`Optimize1qGateDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition)\n", - " - [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation)\n", - "\n", - "\n", - "Additionally, this stage also executes a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Scheduling\n", - "\n", - "This last stage is only run if it is explicitly called for (similar to the Init stage) and does not run by default (though a method can be specified by setting the `scheduling_method` argument when calling `transpile()`). The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized. These passes focus on accounting for all the idle time in a circuit. At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend. Scheduling a circuit involves two parts: analysis and constraint mapping, followed by a padding pass. The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis)), which analyzes the circuit and records the start time of each instruction in the circuit into a schedule. Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend. Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling) can be executed." - ] - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "description": "Overview of transpiler stages and the PassManager", - "kernelspec": { - "display_name": "qiskit-wKX2ZNlv-py3.11", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.6" - }, - "title": "Transpiler stages and the pass manager" - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 604fe50aa3d5ece0d2921aa42d61a386bdbbc9d1 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 15:02:42 -0500 Subject: [PATCH 41/48] rename placeholder --- docs/transpile/{passmanagers.mdx => transpiler-stages.mdx} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/transpile/{passmanagers.mdx => transpiler-stages.mdx} (100%) diff --git a/docs/transpile/passmanagers.mdx b/docs/transpile/transpiler-stages.mdx similarity index 100% rename from docs/transpile/passmanagers.mdx rename to docs/transpile/transpiler-stages.mdx From 0c88d51aa11b2b977f41f613b7f4b169b898c939 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 15:10:15 -0500 Subject: [PATCH 42/48] more cleanup --- docs/transpile/customized-passmanagers.ipynb | 22 ++++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 5c43c943738..44415f048b2 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Customizing a transpilation pipeline\n", + "# Customize a transpilation pipeline\n", "\n", "In the [Transpiler stages](transpiler-stages) topic we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassManager` objects, writing your own bespoke transpiler passes, and installing them as plugins. Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" ] @@ -13,9 +13,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Utilizing the StagedPassManager\n", + "## Use the StagedPassManager\n", "\n", - "This class enables building a transpilation pipeline from a set of stages. Each `StagedPassManager` contains a list of stages which are executed in a fixed order, with each stage specified by its own `PassManager` instance. Each stage can also be prepended or appended with a `pre_` and `post_` which are particularly useful if you would like to add other `PassManagers` that contain conditional logic and programatically control the flow of passes.\n", + "This class enables building a transpilation pipeline from a set of stages. Each `StagedPassManager` contains a list of stages that are executed in a fixed order, with each stage specified by its own `PassManager` instance. Each stage can also be prepended or appended with a `pre_` and `post_`, which are particularly useful if you would like to add other `PassManagers` that contain conditional logic and programmatically control the flow of passes.\n", "\n", "Note that when using a `StagedPassManager` you are not able to modify the individual passes, only the stages and their associated passes or passmanagers. The default stages are the same that have been specified in previous sections:\n", "\n", @@ -80,19 +80,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The code above will create a new `StagedPassManager` that has 2 stages, `init` and `translation`. These stages will be executed in order and any stage set to `None` will be skipped. This list is immutable and stored as a tuple once the `StagedPassManager` is instantiated. Additionally, if a stage is provided multiple times (i.e. at different relative positions), the associated passes, including `pre_` and `post_`, will run once per declaration in the order they were declared. If a `PassManager` is being used for more than 1 stage (e.g. a `Pass` covers both Layout and Routing) you will want to set that to the earliest stage in the sequence it covers." + "The code above will create a new `StagedPassManager` that has two stages, `init` and `translation`. These stages will be executed in order and any stage set to `None` will be skipped. This list is immutable and stored as a tuple once the `StagedPassManager` is instantiated. Additionally, if a stage is provided multiple times (in other words, at different relative positions), the associated passes, including `pre_` and `post_`, will run once per declaration in the order they were declared. If a `PassManager` is being used for more than one stage (for example, a `Pass` covers both Layout and Routing) you will want to set that to the earliest stage in the sequence it covers." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Using your own PassManager\n", + "## Build your own PassManager\n", "\n", - "In addition to modifying the preset pass managers, it is also possible to build an entirely custom pipeline for optimizing your quantum circuits. The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the passmanager to use or utilize passes which are installed as plugins which are covered later in this document.\n", + "In addition to modifying the preset pass managers, it is also possible to build an entirely custom pipeline for optimizing your quantum circuits. The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the pass manager to use, or utilize passes that are installed as plugins, and are covered later in this topic.\n", "\n", "\n", - "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset.md#stage-generator-functions) may also be useful for you when constructing custom passmanagers. They generate stages which provide common functionality used in many passmanagers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." + "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset.md#stage-generator-functions) may also be useful for you when constructing custom pass managers. They generate stages that provide common functionality used in many pass managers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." ] }, { @@ -215,7 +215,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A `PassManager` can be created using a list of passes to execute, or, once instantiated, can have passes appended to it." + "A `PassManager` can be created using a list of passes to execute or, once instantiated, can have passes appended to it." ] }, { @@ -285,16 +285,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`PassManagers` can also include control flow instructions to programatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController.md) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController.md). (*this need more explanation*)" + "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController.md) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController.md). (*this need more explanation*)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Building & Using Custom Plugins\n", + "## Build and use custom plugins\n", "\n", - "In this section we'll discuss installing and utilizing custom plugins, as well as writing your own from a `PassManager` object....\n", + "In this section we'll discuss installing and using custom plugins, as well as writing your own from a `PassManager` object....\n", "\n", "Look to the page on writing [transpiler plugins](https://qiskit.org/documentation/apidoc/transpiler_plugins.html#plugin-api)" ] From f11683d6028ee13d095d6da59f451ce03ac7bdba Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 15:21:04 -0500 Subject: [PATCH 43/48] update links --- docs/transpile/customized-passmanagers.ipynb | 4 ++-- docs/transpile/index.mdx | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 44415f048b2..46a89da023b 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -92,7 +92,7 @@ "In addition to modifying the preset pass managers, it is also possible to build an entirely custom pipeline for optimizing your quantum circuits. The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the pass manager to use, or utilize passes that are installed as plugins, and are covered later in this topic.\n", "\n", "\n", - "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset.md#stage-generator-functions) may also be useful for you when constructing custom pass managers. They generate stages that provide common functionality used in many pass managers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." + "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset#stage-generator-functions) may also be useful for you when constructing custom pass managers. They generate stages that provide common functionality used in many pass managers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." ] }, { @@ -285,7 +285,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController.md) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController.md). (*this need more explanation*)" + "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController). (*this need more explanation*)" ] }, { diff --git a/docs/transpile/index.mdx b/docs/transpile/index.mdx index 269b6559730..ebcbe558ffc 100644 --- a/docs/transpile/index.mdx +++ b/docs/transpile/index.mdx @@ -11,7 +11,7 @@ Transpilation is the process of rewriting a given input circuit to match the top A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to be able to easily write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, allowing you to greatly reduce the depth and complexity of your quantum circuits. Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by `PassManager` and `StagedPassManager` objects. The `StagedPassManager` will orchestrate the execution of one or more `PassManagers` and determine the order in which they are executed, while the `PassManager` object is merely a collection of one or more passes. Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Passes` as the individual musicians. In this way, you have the power to compose hardware-efficient quantum circuits that allow you to execute utility-scale work while keeping noise manageable. -Find more information about the pass manager stages in the [Transpiler stages and preset pass managers](passmanagers) topic. +Find more information about the pass manager stages in the [Transpiler stages](transpiler-stages) topic. ## Transpiler stages @@ -31,7 +31,7 @@ Qiskit's prebuilt transpiler pipeline consists of six fundamental stages: ## Default transpilation The basic usage of the transpiler is to call the [`qiskit.compiler.transpile()`](../api/qiskit/compiler#qiskit.compiler.transpile) function. This will generate and run one of the preset `StagedPassManager`s based on, among other options, an `optimization_level` flag that can be set to either 0, 1, 2, or 3. Higher levels generate more optimized circuits, at the expense of longer transpilation times. -If you'd like to read more about the preset pass managers or the transpiler stages, visit the section on [Transpiler stages and preset PassManagers](passmanagers). To learn how to use the `.transpile()` function, see the [Transpilation default settings and configuration options](defaults_and_configuration_options) topic. +If you'd like to read more about the preset pass managers or the transpiler stages, visit the [Transpiler stages](transpiler-stages) topic. To learn how to use the `.transpile()` function, see the [Transpilation default settings and configuration options](defaults_and_configuration_options) topic. ## Customizing passes From 5fa6aeb93bff349dbdfb3c5f2fb5896ca1a946ab Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 15:27:10 -0500 Subject: [PATCH 44/48] update api links --- docs/transpile/customized-passmanagers.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 46a89da023b..0443cf60293 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -92,7 +92,7 @@ "In addition to modifying the preset pass managers, it is also possible to build an entirely custom pipeline for optimizing your quantum circuits. The purpose of the `PassManager` object is to execute one or more *passes* on a quantum circuit. All of the available passes within Qiskit can be found from `qiskit.transpiler.passes`. You are also free to write your own passes for the pass manager to use, or utilize passes that are installed as plugins, and are covered later in this topic.\n", "\n", "\n", - "The [`StagedGeneratorFunctions`](../api/qiskit/transpiler_preset#stage-generator-functions) may also be useful for you when constructing custom pass managers. They generate stages that provide common functionality used in many pass managers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." + "The [`StagedGeneratorFunctions`](/api/qiskit/transpiler_preset#stage-generator-functions) may also be useful for you when constructing custom pass managers. They generate stages that provide common functionality used in many pass managers. For example, `generate_embed_passmanager()` can be used to generate a stage to \"embed\" a selected initial Layout from a layout pass to the specified target device." ] }, { @@ -285,7 +285,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](../api/qiskit/qiskit.transpiler.DoWhileController) or [`ConditionalController`](../api/qiskit/qiskit.transpiler.ConditionalController). (*this need more explanation*)" + "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](/api/qiskit/qiskit.transpiler.DoWhileController) or [`ConditionalController`](/api/qiskit/qiskit.transpiler.ConditionalController). (*this need more explanation*)" ] }, { From 949ef92aaf7edb711c078cb09642e0ff68469bec Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 15:34:46 -0500 Subject: [PATCH 45/48] Update customized-passmanagers.ipynb --- docs/transpile/customized-passmanagers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb index 0443cf60293..4cdf7f366f3 100644 --- a/docs/transpile/customized-passmanagers.ipynb +++ b/docs/transpile/customized-passmanagers.ipynb @@ -285,7 +285,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](/api/qiskit/qiskit.transpiler.DoWhileController) or [`ConditionalController`](/api/qiskit/qiskit.transpiler.ConditionalController). (*this need more explanation*)" + "`PassManagers` can also include control flow instructions to programmatically execute different passes. Once instantiated, new passes can be appended by the `PassManager.append()` method and can include a dictionary of flow controller plugins such as the [`DoWhileContoller`](/api/qiskit/qiskit.passmanager.DoWhileController) or [`ConditionalController`](/api/qiskit/qiskit.passmanager.ConditionalController). (*this need more explanation*)" ] }, { From 548278ea461f6daacdab00e9f0aaf120f10e0e54 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 16:02:22 -0500 Subject: [PATCH 46/48] bring over file from #335 --- docs/transpile/writing-passes.ipynb | 175 ++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 docs/transpile/writing-passes.ipynb diff --git a/docs/transpile/writing-passes.ipynb b/docs/transpile/writing-passes.ipynb new file mode 100644 index 00000000000..7efab0f6cc2 --- /dev/null +++ b/docs/transpile/writing-passes.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Writing your own Pass\n", + "\n", + "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DAG Representation\n", + "\n", + "\n", + "However, before we start it is important to first introduce the internal representation of quantum circuits in Qiskit, the *Directed Acyclic Graph* or **DAG**. If you want to follow along here, you will need to install the `pydot` library and the `graphivz` library for the DAG plotting functions. Use the python package manager of your choice (such as `pip` or `conda`) to install `pydot` and your system's native package manager (e.g. `apt`, `brew`, `yum`, `dnf`, etc.) for `graphivz`.\n", + "\n", + "\n", + "In Qiskit, specifically within the transpilation stages, circuits are represented using a Directed Acyclic Graph (DAG). In general, a DAG is composed of *vertices* (also known as \"nodes\") and directed *edges* which connect pairs of vertices in a particular orientation. This representation is stored using `qiskit.dagcircuit.DAGCircuit` objects which are composed of invididual `DagNode` objects. The advantage of this representation over a pure list of gates (i.e. a *netlist*) is that the flow of information between operators is explicit, making it easier to make transformation decisions. \n", + "\n", + "Let's look at a simple example to understand the DAG a bit more by preparing a simple circuit which prepares a bell state and applies an $R_Z$ rotation depending on the outcome of a measurement." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", + "from qiskit.dagcircuit import DAGCircuit\n", + "import numpy as np\n", + "q = QuantumRegister(3, 'q')\n", + "c = ClassicalRegister(3, 'c')\n", + "circ = QuantumCircuit(q, c)\n", + "circ.h(q[0])\n", + "circ.cx(q[0], q[1])\n", + "circ.measure(q[0], c[0])\n", + "circ.rz(np.pi/2, q[1]).c_if(c, 2)\n", + "circ.draw(output='mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then view this circuit's DAG by using the `qiskit.tools.visualization.dag_drawer()` function. You'll notice there are three kinds of graph nodes: qubit/clbit nodes (green), operation nodes (blue), and output nodes (red). Each edge indicates data flow (or dependency) between two nodes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Could not save to JPEG for display", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[39m=\u001b[39m RAWMODE[im\u001b[39m.\u001b[39;49mmode]\n\u001b[1;32m 640\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", + "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave(b, image_format, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m save_handler(\u001b[39mself\u001b[39;49m, fp, filename)\n\u001b[1;32m 2414\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcannot write mode \u001b[39m\u001b[39m{\u001b[39;00mim\u001b[39m.\u001b[39mmode\u001b[39m}\u001b[39;00m\u001b[39m as JPEG\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mOSError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[39m=\u001b[39m im\u001b[39m.\u001b[39mencoderinfo\n", + "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib/python3.11/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[39m=\u001b[39m get_real_method(obj, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[39mif\u001b[39;00m method \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[39mreturn\u001b[39;00m method()\n\u001b[1;32m 345\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_repr_jpeg_\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[39m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_repr_image(\u001b[39m\"\u001b[39;49m\u001b[39mJPEG\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/qiskit-playground-qf9l8Iyc-py3.11/lib64/python3.11/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mCould not save to \u001b[39m\u001b[39m{\u001b[39;00mimage_format\u001b[39m}\u001b[39;00m\u001b[39m for display\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[39mreturn\u001b[39;00m b\u001b[39m.\u001b[39mgetvalue()\n", + "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.converters import circuit_to_dag\n", + "from qiskit.tools.visualization import dag_drawer\n", + "dag = circuit_to_dag(circ)\n", + "dag_drawer(dag)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Types of Transpilation Passes\n", + "\n", + "- Go over the differences between an `AnalysisPass` and a `TransformationPass`-\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a custom Mapping pass\n", + "\n", + "[Use this example for content](https://qiskit.org/documentation/tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.html#Implementing-a-BasicMapper-Pass)\n", + "\n", + "[A helpful page on synthesis plugins](https://qiskit.org/documentation/apidoc/transpiler_synthesis_plugins.html)\n", + "\n", + "[The information from this example](https://qiskit.org/documentation/apidoc/synthesis_aqc.html) may also be helpful\n", + "\n", + "\n", + "[Perhaps information about the multiplexor representation is useful here?](https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "description": "How to write your own transpiler pass, including what is DAG, analysis vs. transformation passes", + "kernelspec": { + "display_name": "qiskit-wKX2ZNlv-py3.11", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "title": "Write your own passes" + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5329615b5254512dd1e502dadcc2b3f82ae67ed1 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 16:03:36 -0500 Subject: [PATCH 47/48] Update _toc.json --- docs/transpile/_toc.json | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index 3b28c14010f..b3c3a9041c5 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -10,9 +10,13 @@ "url": "/transpile/transpiler-stages" }, { - "title": "Customizing Transpilation", + "title": "Customize a transpilation pipeline", "url": "/transpile/customized-passmanagers" }, + { + "title": "Write your own pass", + "url": "/transpile/writing-passes" + }, { "title": "PLACEHOLDER", "url": "/transpile/defaults_and_configuration_options" From fa76226b904cd66bba47e01ab44847292d3e9e40 Mon Sep 17 00:00:00 2001 From: ABBY CROSS Date: Fri, 17 Nov 2023 16:07:08 -0500 Subject: [PATCH 48/48] fix link --- docs/transpile/writing-passes.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/transpile/writing-passes.ipynb b/docs/transpile/writing-passes.ipynb index 7efab0f6cc2..5816b7c08e0 100644 --- a/docs/transpile/writing-passes.ipynb +++ b/docs/transpile/writing-passes.ipynb @@ -6,7 +6,7 @@ "source": [ "# Writing your own Pass\n", "\n", - "In the [previous section](passmanagers.ipynb) we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" + "In the [Transpiler stages](transpiler-stages) topic we went over the default behavior of the transpiler and the various stages that compose a transpilation pipeline. Qiskit allows you to create custom transpilation workflows using: the `PassManager` and `StagedPassMager` objects, writing your own bespoke transpiler passes, and Here we will take a more careful look at the `PassManager` and `StagedPassManager` objects to customize which passes are executed at what stage and walk through a few examples.\n" ] }, {