diff --git a/docs/transpile/_toc.json b/docs/transpile/_toc.json index 0b192bcf7d2..d375181bdfb 100644 --- a/docs/transpile/_toc.json +++ b/docs/transpile/_toc.json @@ -1,18 +1,25 @@ { - "title": "Transpile", - "children": [ - { - "title": "Introduction", - "url": "/transpile" - }, - { - "title": "Transpiler stages", - "url": "/transpile/transpiler-stages" - }, - { - "title": "PLACEHOLDER", - "url": "/transpile/defaults_and_configuration_options" - } - ] - } - \ No newline at end of file + "title": "Transpile", + "children": [ + { + "title": "Introduction", + "url": "/transpile" + }, + { + "title": "Transpiler stages", + "url": "/transpile/transpiler-stages" + }, + { + "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" + } + ] +} \ No newline at end of file diff --git a/docs/transpile/customized-passmanagers.ipynb b/docs/transpile/customized-passmanagers.ipynb new file mode 100644 index 00000000000..4cdf7f366f3 --- /dev/null +++ b/docs/transpile/customized-passmanagers.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use the StagedPassManager\n", + "\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", + "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", + "\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 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": [ + "## 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 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." + ] + }, + { + "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": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "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', style='clifford')" + ] + }, + { + "cell_type": "code", + "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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", + "text/plain": [ + "
" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "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', style='clifford')\n", + "\n", + "# Add in another pass as example to decompose to backend basis gates\n" + ] + }, + { + "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.passmanager.DoWhileController) or [`ConditionalController`](/api/qiskit/qiskit.passmanager.ConditionalController). (*this need more explanation*)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build and use custom plugins\n", + "\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)" + ] + }, + { + "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.6" + }, + "title": "Transpiler Stages & the PassManager" + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/transpile/writing-passes.ipynb b/docs/transpile/writing-passes.ipynb new file mode 100644 index 00000000000..5816b7c08e0 --- /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 [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" + ] + }, + { + "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 +}