{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Qubit mapping and routing\n", "\n", "**Download this notebook - {nb-download}`mapping_example.ipynb`**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this tutorial we will show how the problem of mapping from logical quantum circuits to physically permitted circuits is solved automatically in TKET. The basic examples require only the installation of pytket, ```pip install pytket```." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is a wide variety of different blueprints for realising quantum computers, including the well known superconducting and ion trap devices. Different devices come with different constraints, such as a limited primitive gate set for universal quantum computing. Often this limited gate set accommodates an additional constraint, that two-qubit gates can not be executed between all pairs of qubits." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In software, typically this constraint is presented as a \"connectivity\" graph where vertices connected by an edge represents pairs of physical qubits which two-qubit gates can be executed on. As programmers usually write logical quantum circuits with no sense of architecture (or may want to run their circuit on a range of hardware with different connectivity constraints), most quantum software development kits offer the means to automatically solve this constraint. One common way is to automatically add logical ```SWAP``` gates to a Circuit, changing the position of logical qubits on physical qubits until a two-qubit gate can be realised. This is an active area of research in quantum computing and a problem we discuss in our paper \"On The Qubit Routing Problem\" - arXiv:1902.08091." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In TKET this constraint is represented by the ```Architecture``` class. An Architecture object requires a coupling map to be created, a list of pairs of qubits which defines where two-qubit primitives may be executed. A coupling map can be produced naively by the integer indexing of nodes and edges in some architecture." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from pytket.architecture import Architecture\n", "from pytket.circuit import Node" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import networkx as nx\n", "from typing import List, Union, Tuple" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def draw_graph(coupling_map: List[Union[Tuple[int, int], Tuple[Node, Node]]]):\n", " coupling_graph = nx.Graph(coupling_map)\n", " nx.draw(coupling_graph, labels={node: node for node in coupling_graph.nodes()})" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simple_coupling_map = [(0, 1), (1, 2), (2, 3)]\n", "simple_architecture = Architecture(simple_coupling_map)\n", "draw_graph(simple_coupling_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively we could use the `Node` class to assign our nodes - you will see why this can be helpful later. Lets create an Architecture with an identical graph:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "node_0 = Node(\"e0\", 0)\n", "node_1 = Node(\"e1\", 1)\n", "node_2 = Node(\"e2\", 2)\n", "node_3 = Node(\"e3\", 3)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "id_coupling_map = [(node_0, node_1), (node_1, node_2), (node_2, node_3)]\n", "id_architecture = Architecture(id_coupling_map)\n", "draw_graph(id_coupling_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also create an ID with an arbitrary-dimensional index. Let us make a 2x2x2 cube:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "node_000 = Node(\"cube\", [0, 0, 0])\n", "node_001 = Node(\"cube\", [0, 0, 1])\n", "node_010 = Node(\"cube\", [0, 1, 0])\n", "node_011 = Node(\"cube\", [0, 1, 1])\n", "node_100 = Node(\"cube\", [1, 0, 0])\n", "node_101 = Node(\"cube\", [1, 0, 1])\n", "node_110 = Node(\"cube\", [1, 1, 0])\n", "node_111 = Node(\"cube\", [1, 1, 1])" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "cube_coupling_map = [\n", " (node_000, node_001),\n", " (node_000, node_010),\n", " (node_010, node_011),\n", " (node_001, node_011),\n", " (node_000, node_100),\n", " (node_001, node_101),\n", " (node_010, node_110),\n", " (node_011, node_111),\n", " (node_100, node_101),\n", " (node_100, node_110),\n", " (node_110, node_111),\n", " (node_101, node_111),\n", "]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cube_architecture = Architecture(cube_coupling_map)\n", "draw_graph(cube_coupling_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To avoid that tedium though we could just use our SquareGrid Architecture:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "from pytket.architecture import SquareGrid" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "alternative_cube_architecture = SquareGrid(2, 2, 2)\n", "draw_graph(alternative_cube_architecture.coupling)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The current range of quantum computers are commonly referred to as Noisy-Intermediate-Scale-Quantum devices i.e. NISQ devices. The impact of noise is a primary concern during compilation and incentivizes producing physically permitted circuits that have a minimal number of gates. For this reason benchmarking in this area is often completed by comparing the final number of two-qubit (or particularly SWAP gates) in compiled circuits." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However it is important to remember that adding logical SWAP gates to minimise gate count is not the only way this constraint can be met, with large scale architecture-aware synthesis methods and fidelity aware methods amongst other approaches producing viable physically permitted circuits. It is likely that no SINGLE approach is better for all circuits, but the ability to use different approaches where best fitted will give the best results during compilation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Producing physically valid circuits is completed via the `MappingManager` class, which aims to accommodate a wide range of approaches." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "from pytket.mapping import MappingManager" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A `MappingManager` object requires an `Architecture` object at construction." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "mapping_manager = MappingManager(id_architecture)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All mapping is done through the `MappingManager.route_circuit` method. The `MappingManager.route_circuit` method has two arguments, the first a Circuit to be routed (which is mutated), the second a `List[RoutingMethodCircuit]` object that defines how the mapping is completed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Later we will look at defining our own `RoutingMethodCircuit` objects, but initially lets consider one thats already available." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from pytket.mapping import LexiLabellingMethod, LexiRouteRoutingMethod" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "lexi_label = LexiLabellingMethod()\n", "lexi_route = LexiRouteRoutingMethod(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `lexi_route` object here is of little use outside `MappingManager`. Note that it takes a lookahead parameter, which will affect the performance of the method, defining the number of two-qubit gates it considers when finding `SWAP` gates to add." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "from pytket import Circuit, OpType\n", "from pytket.circuit import display" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also look at which logical qubits are interacting." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from pytket.utils import Graph" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Qubit connectivity\n", "\n", "\n", "\n", "q[0]\n", "\n", "q[0]\n", "\n", "\n", "\n", "q[1]\n", "\n", "q[1]\n", "\n", "\n", "\n", "q[0]--q[1]\n", "\n", "\n", "\n", "\n", "q[2]\n", "\n", "q[2]\n", "\n", "\n", "\n", "q[0]--q[2]\n", "\n", "\n", "\n", "\n", "q[3]\n", "\n", "q[3]\n", "\n", "\n", "\n", "q[0]--q[3]\n", "\n", "\n", "\n", "\n", "q[1]--q[2]\n", "\n", "\n", "\n", "\n", "q[1]--q[3]\n", "\n", "\n", "\n", "\n", "q[2]--q[3]\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Graph(c).get_qubit_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By running the `MappingManager.route_circuit` method on our circuit `c` with the `LexiLabellingMethod` and `LexiRouteRoutingMethod` objects as an argument, qubits in `c` with some physical requirements will be relabelled and the qubit graph modified (by the addition of SWAP gates and relabelling some CX as BRIDGE gates) such that the qubit graph is isomorphic to some subgraph of the full architecture." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "mapping_manager.route_circuit(c, [lexi_label, lexi_route])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The graph:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Qubit connectivity\n", "\n", "\n", "\n", "e1[1]\n", "\n", "e1[1]\n", "\n", "\n", "\n", "e0[0]\n", "\n", "e0[0]\n", "\n", "\n", "\n", "e1[1]--e0[0]\n", "\n", "\n", "\n", "\n", "e2[2]\n", "\n", "e2[2]\n", "\n", "\n", "\n", "e1[1]--e2[2]\n", "\n", "\n", "\n", "\n", "e3[3]\n", "\n", "e3[3]\n", "\n", "\n", "\n", "e2[2]--e3[3]\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Graph(c).get_qubit_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The resulting circuit may also change if we reduce the lookahead parameter." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "mapping_manager.route_circuit(c, [lexi_label, LexiRouteRoutingMethod(1)])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also pass multiple `RoutingMethod` options for Routing in a ranked List. Each `RoutingMethod` option has a function for checking whether it can usefully modify a subcircuit at a stage in Routing. To choose, each method in the List is checked in order until one returns True. This will be discussed more later." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can aid the mapping procedure by relabelling qubits in advance. This can be completed using the `Placement` class." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "from pytket.placement import Placement, LinePlacement, GraphPlacement" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The default ```Placement``` assigns logical qubits to physical qubits as they are encountered during routing. ```LinePlacement``` uses a strategy described in https://arxiv.org/abs/1902.08091. ```GraphPlacement``` is described in Section 7.1 of https://arxiv.org/abs/2003.10611. Lets look at how we can use the ```LinePlacement``` class.`" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "line_placement = LinePlacement(id_architecture)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "line_placement.place(c)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that one qubit remains unplaced in this example. `LexiRouteRoutingMethod` will dynamically assign it during mapping." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Different placements will lead to different selections of SWAP gates being added. However each different routed circuit will preserve the original unitary action of the full circuit while respecting connectivity constraints." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "mapping_manager.route_circuit(c, [lexi_label, lexi_route])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The graph:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Qubit connectivity\n", "\n", "\n", "\n", "e0[0]\n", "\n", "e0[0]\n", "\n", "\n", "\n", "e1[1]\n", "\n", "e1[1]\n", "\n", "\n", "\n", "e0[0]--e1[1]\n", "\n", "\n", "\n", "\n", "e2[2]\n", "\n", "e2[2]\n", "\n", "\n", "\n", "e0[0]--e2[2]\n", "\n", "\n", "\n", "\n", "e1[1]--e2[2]\n", "\n", "\n", "\n", "\n", "e3[3]\n", "\n", "e3[3]\n", "\n", "\n", "\n", "e2[2]--e3[3]\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Graph(c).get_qubit_graph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, small changes to the depth of lookahead or the original assignment of `Architecture` `Node` can greatly affect the resulting physical circuit for the `LexiRouteRoutingMethod` method. Considering this variance, it should be possible to easily throw additional computational resources at the problem if necessary, which is something TKET is leaning towards with the ability to define custom `RoutingCircuitMethod` objects." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To define a new `RoutingMethodCircuit` method though, we first need to understand how it is used in `MappingManager` and routing. The `MappingManager.route_circuit` method treats the global problem of mapping to physical circuits as many sequential sub-problems. Consider the following problem." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "from pytket import Circuit" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "from pytket.placement import place_with_map" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "CX\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "cluster_12\n", "\n", "CX\n", "\n", "\n", "cluster_13\n", "\n", "CX\n", "\n", "\n", "cluster_14\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(6, 0)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(9, 0)->(13, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 0)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 1)->(12, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(11, 0)->(14, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(11, 1)->(12, 1)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(12, 1)->(13, 1)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(13, 0)->(14, 1)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ = Circuit(4).CX(0, 1).CX(1, 2).CX(0, 2).CX(0, 3).CX(2, 3).CX(1, 3).CX(0, 1)\n", "naive_map = {\n", " circ.qubits[0]: node_0,\n", " circ.qubits[1]: node_1,\n", " circ.qubits[2]: node_2,\n", " circ.qubits[3]: node_3,\n", "}\n", "place_with_map(circ, naive_map)\n", "Graph(circ).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So what happens when we run the following?" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "CX\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "cluster_12\n", "\n", "CX\n", "\n", "\n", "cluster_13\n", "\n", "CX\n", "\n", "\n", "cluster_14\n", "\n", "SWAP\n", "\n", "\n", "cluster_15\n", "\n", "SWAP\n", "\n", "\n", "cluster_16\n", "\n", "BRIDGE\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(15, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(6, 0)->(15, 0)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(14, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(14, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 0)->(14, 1)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 0)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(10, 1)->(15, 1)\n", "\n", "\n", "\n", "\n", "\n", "(16, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(11, 0)->(16, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(12, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(11, 1)->(12, 1)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(12, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(16, 2)\n", "\n", "2\n", "\n", "\n", "\n", "(12, 1)->(16, 2)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(13, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(13, 1)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(16, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(14, 0)->(16, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 0)->(12, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 1)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(16, 0)->(13, 1)\n", "\n", "\n", "\n", "\n", "\n", "(16, 1)->(13, 0)\n", "\n", "\n", "\n", "\n", "\n", "(16, 2)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mapping_manager.route_circuit(circ, [lexi_route])\n", "Graph(circ).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sequential mapping typically works by partitioning the circuit into two, a first partition comprising a connected subcircuit that is physically permitted, a second partition that is not. Therefore, the first thing `MappingManager.route_circuit` does is find this partition for the passed circuit, by iterating through gates in the circuit." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will construct the partitions ourselves for illustrative purposes. Lets assume we are routing for the four qubit line architecture (qubits are connected to adjacent indices) \"simple_architecture\" we constructed earlier." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(6, 0)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(8, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 1)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ_first_partition = Circuit(4).CX(0, 1).CX(1, 2)\n", "place_with_map(circ_first_partition, naive_map)\n", "Graph(circ_first_partition).get_DAG()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "CX\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "cluster_12\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(2, 0)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(6, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(9, 0)->(12, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(10, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(10, 1)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(12, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(11, 0)->(12, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 1)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ_second_partition = Circuit(4).CX(0, 2).CX(0, 3).CX(2, 3).CX(1, 3).CX(0, 1)\n", "place_with_map(circ_second_partition, naive_map)\n", "Graph(circ_second_partition).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that there are gates in the second partition that would be physically permitted, if they were not dependent on other gates that are not." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next step is to modify the second partition circuit to move it closer being physically permitted. Here the `LexiRouteRoutingMethod` as before will either insert a SWAP gate at the start of the partition, or will substitute a CX gate in the first slice of the partition with a BRIDGE gate." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The option taken by `LexiRouteRoutingethod(1)` is to insert a SWAP gate between the first two nodes of the architecture, swapping their logical states. How does this change the second partition circuit?" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "SWAP\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "CX\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "cluster_12\n", "\n", "CX\n", "\n", "\n", "cluster_13\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(6, 0)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(12, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(12, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(9, 0)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(9, 1)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 0)->(13, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(10, 1)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(11, 1)->(12, 1)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(12, 0)->(13, 1)\n", "\n", "\n", "\n", "\n", "\n", "(12, 1)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ_second_partition = (\n", " Circuit(4).SWAP(0, 1).CX(1, 2).CX(1, 3).CX(2, 3).CX(0, 3).CX(1, 0)\n", ")\n", "place_with_map(circ_second_partition, naive_map)\n", "Graph(circ_second_partition).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Leaving the full circuit as:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "SWAP\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "cluster_12\n", "\n", "CX\n", "\n", "\n", "cluster_13\n", "\n", "CX\n", "\n", "\n", "cluster_14\n", "\n", "CX\n", "\n", "\n", "cluster_15\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(12, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(6, 0)->(12, 1)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 0)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(14, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 0)->(14, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 1)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(12, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(11, 0)->(12, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(11, 1)->(13, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(12, 0)->(15, 0)\n", "\n", "\n", "\n", "\n", "\n", "(13, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(12, 1)->(13, 1)\n", "\n", "\n", "\n", "\n", "\n", "(13, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(13, 1)->(14, 1)\n", "\n", "\n", "\n", "\n", "\n", "(15, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(14, 0)->(15, 1)\n", "\n", "\n", "\n", "\n", "\n", "(14, 1)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(15, 1)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "full_circuit = (\n", " Circuit(4).CX(0, 1).CX(1, 2).SWAP(0, 1).CX(1, 2).CX(1, 3).CX(2, 3).CX(0, 3).CX(1, 0)\n", ")\n", "place_with_map(full_circuit, naive_map)\n", "Graph(full_circuit).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After a modification is made the partition is updated." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first partition:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "SWAP\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(2, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(6, 0)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 1)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 0)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(10, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(10, 1)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ_first_partition = Circuit(4).CX(0, 1).CX(1, 2).SWAP(0, 1).CX(1, 2)\n", "place_with_map(circ_first_partition, naive_map)\n", "Graph(circ_first_partition).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second partition:" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CX\n", "\n", "\n", "cluster_9\n", "\n", "CX\n", "\n", "\n", "cluster_10\n", "\n", "CX\n", "\n", "\n", "cluster_11\n", "\n", "CX\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(10, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(10, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(2, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(9, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(4, 0)->(9, 0)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(6, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(11, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(8, 0)->(11, 0)\n", "\n", "\n", "\n", "\n", "\n", "(9, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(8, 1)->(9, 1)\n", "\n", "\n", "\n", "\n", "\n", "(9, 0)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(9, 1)->(10, 1)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(10, 0)->(11, 1)\n", "\n", "\n", "\n", "\n", "\n", "(10, 1)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(11, 1)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circ_second_partition = Circuit(4).CX(1, 3).CX(2, 3).CX(0, 3).CX(1, 0)\n", "place_with_map(circ_second_partition, naive_map)\n", "Graph(circ_second_partition).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This pattern of modification and updating the partition is repeated until the partition has reached the end of the circuit, i.e. the back side of the partition has no gates in it. Also note that the process of updating the partition has been simplified for this example with \"physically permitted\" encapsulating two-qubit gate constraints only - in the future we expect other arity gates to provide constraints that need to be met. Also note that any modification to the second circuit can willfully modify the qubit labelling and a token swapping network will be automatically added to conform to the new labelling." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now enough about how `MappingManager` works to add our own `RoutingMethodCircuit`. While `LexiRouteRoutingMethod` is implemented in c++ TKET, giving it some advantages, via lambda functions we can define our own `RoutingMethodCircuit` in python." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A python defined `RoutingMethodCircuit` requires three arguments. The first is a function that given a Circuit (the circuit after the partition) and an Architecture, returns a bool (determining whether the new circuit should be substituted in a full routing process), a new Circuit (a modification of the original circuit such as an added SWAP) a Dict between qubits reflecting any relabelling done in the method, and a Dict between qubits giving any implicit permutation of qubits (such as by adding a SWAP). For some clarity (we will write an example later), lets look at an example function declaration." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "from typing import Dict" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "def route_subcircuit_func(\n", " circuit: Circuit, architecture: Architecture\n", ") -> Tuple[bool, Circuit, Dict[Node, Node], Dict[Node, Node]]:\n", " return ()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first return is a bool which detemrines if a given `RoutingMethodCircuit` is suitable for providing a solution at a given partition. `MappingManager.route_circuit` accepts a List of of `RoutingMethod` defining how solutions are found. At the point the partition circuit is modified, the circuit is passed to `RoutingMethodCircuit.routing_method` which additionally to finding a subcircuit substitution, should determine whether it can or can't helpfully modify the partition boundary circuit, and return True if it can. The first `RoutingMethodCircuit` to return True is then used for modification - meaning the ordering of List elements is important." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The third argument sets the maximum number of gates given in the passed Circuit and the fourth argument sets the maximum depth in the passed Circuit." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`LexiRouteRoutingMethod` will always return True, because it can always find some helpful SWAP to insert, and it can dynamically assign logical to physical qubits. Given this, lets construct a more specialised modification - an architecture-aware decomposition of a distance-2 CRy gate. Lets write our function type declarations for each method:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "def distance2_CRy_decomp(\n", " circuit: Circuit, architecture: Architecture\n", ") -> Tuple[bool, Circuit, Dict[Node, Node], Dict[Node, Node]]:\n", " return (False, Circuit(), {}, {})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Where do we start? Lets define a simple scope for our solution: for a single gate in the passed circuit (the circuit after the partition) that has OpType CRy, if the two qubits it's acting on are at distance 2 on the architecture, decompose the gate using BRIDGE gates." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first restriction is to only have a single gate from the first slice - we can achieve this by setting both the maximum depth and size parameters to 1." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second restriction is for the gate to have OpType CRy and for the qubits to be at distance 2 - we can check this restriction in a `distance2_CRy_check` method." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "def distance2_CRy_check(circuit: Circuit, architecture: Architecture) -> bool:\n", " if circuit.n_gates != 1:\n", " raise ValueError(\n", " \"Circuit for CRy check should only have 1 gate, please change parameters of method declaration.\"\n", " )\n", " command = circuit.get_commands()[0]\n", " if command.op.type == OpType.CRy:\n", " # Architecture stores qubits under `Node` identifier\n", " n0 = Node(command.qubits[0].reg_name, command.qubits[0].index)\n", " n1 = Node(command.qubits[1].reg_name, command.qubits[1].index)\n", " # qubits could not be placed in circuit, so check before finding distance\n", " if n0 in architecture.nodes and n1 in architecture.nodes:\n", " # means we can run the decomposition\n", " if architecture.get_distance(n0, n1) == 2:\n", " return True\n", " return False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `distance2_CRy_check` confirms whether the required restrictions are respected. Given this, if the `distance2_CRy_decomp` method is called we know where to add the decomposition." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "def distance2_CRy_decomp(\n", " circuit: Circuit, architecture: Architecture\n", ") -> Tuple[bool, Circuit, Dict[Node, Node], Dict[Node, Node]]:\n", " worthwhile_substitution = distance2_CRy_check(circuit, architecture)\n", " if worthwhile_substitution == False:\n", " return (False, Circuit(), {}, {})\n", " command = circuit.get_commands()[0]\n", " qubits = command.qubits\n", " # Architecture stores qubits under `Node` identifier\n", " n0 = Node(qubits[0].reg_name, qubits[0].index)\n", " n1 = Node(qubits[1].reg_name, qubits[1].index)\n", "\n", " # need to find connecting node for decomposition\n", " adjacent_nodes_0 = architecture.get_adjacent_nodes(n0)\n", " adjacent_nodes_1 = architecture.get_adjacent_nodes(n1)\n", " connecting_nodes = adjacent_nodes_0.intersection(adjacent_nodes_1)\n", " if len(connecting_nodes) == 0:\n", " raise ValueError(\"Qubits for distance-2 CRy decomp are not at distance 2.\")\n", " connecting_node = connecting_nodes.pop()\n", " c = Circuit()\n", "\n", " # the \"relabelling map\" empty, and the permutation map is qubit to qubit, so add here\n", " permutation_map = dict()\n", " for q in circuit.qubits:\n", " permutation_map[q] = q\n", " c.add_qubit(q)\n", " # rotation, can assume only parameter as CRy\n", " angle = command.op.params[0]\n", " c.Ry(angle, qubits[1])\n", " # distance-2 CX decomp\n", " c.CX(qubits[0], connecting_node).CX(connecting_node, qubits[1])\n", " c.CX(qubits[0], connecting_node).CX(connecting_node, qubits[1])\n", " # rotation\n", " c.Ry(-1 * angle, qubits[1])\n", " # distance-2 CX decomp\n", " c.CX(qubits[0], connecting_node).CX(connecting_node, qubits[1])\n", " c.CX(qubits[0], connecting_node).CX(connecting_node, qubits[1])\n", "\n", " # the \"relabelling map\" is just qubit to qubit\n", " return (True, c, {}, permutation_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before turning this into a `RoutingMethod` we can try it ourselves." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "Circuit\n", "\n", "\n", "cluster_q_inputs\n", "\n", "\n", "\n", "cluster_q_outputs\n", "\n", "\n", "\n", "cluster_8\n", "\n", "CRy(0.6)\n", "\n", "\n", "\n", "(0, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(8, 0)\n", "\n", "0\n", "\n", "\n", "\n", "(0, 0)->(8, 0)\n", "\n", "\n", "\n", "\n", "\n", "(2, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(3, 0)\n", "\n", "e1[1]\n", "\n", "\n", "\n", "(2, 0)->(3, 0)\n", "\n", "\n", "\n", "\n", "\n", "(4, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(8, 1)\n", "\n", "1\n", "\n", "\n", "\n", "(4, 0)->(8, 1)\n", "\n", "\n", "\n", "\n", "\n", "(6, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(7, 0)\n", "\n", "e3[3]\n", "\n", "\n", "\n", "(6, 0)->(7, 0)\n", "\n", "\n", "\n", "\n", "\n", "(1, 0)\n", "\n", "e0[0]\n", "\n", "\n", "\n", "(5, 0)\n", "\n", "e2[2]\n", "\n", "\n", "\n", "(8, 0)->(1, 0)\n", "\n", "\n", "\n", "\n", "\n", "(8, 1)->(5, 0)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_c = Circuit(4)\n", "test_c.CRy(0.6, 0, 2)\n", "place_with_map(test_c, naive_map)\n", "Graph(test_c).get_DAG()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see, our circuit has one CRy gate at distance two away." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(distance2_CRy_check(test_c, id_architecture))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our method returns True, as expected! We should also test cases where it returns errors or False." ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "test_c_false = Circuit(4)\n", "test_c_false.CRy(0.4, 0, 1)\n", "place_with_map(test_c_false, naive_map)\n", "print(distance2_CRy_check(test_c_false, id_architecture))" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Error reached!\n" ] } ], "source": [ "test_c_error = Circuit(4)\n", "test_c_error.CRy(0.6, 0, 2)\n", "test_c_error.CRy(0.4, 0, 1)\n", "place_with_map(test_c_error, naive_map)\n", "try:\n", " distance2_CRy_check(test_c_error, id_architecture)\n", "except ValueError:\n", " print(\"Error reached!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Does the decomposition work?" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "test_c = Circuit(4)\n", "test_c.CRy(0.6, 0, 2)\n", "place_with_map(test_c, naive_map)\n", "decomp = distance2_CRy_decomp(test_c, id_architecture)\n", "display.render_circuit_jupyter(decomp[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Great! Our check function and decomposition method are both working. Lets wrap them into a `RoutingMethodCircuit` and try them out." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "from pytket.mapping import RoutingMethodCircuit" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "cry_rmc = RoutingMethodCircuit(distance2_CRy_decomp, 1, 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use our original `MappingManager` object as it is defined for the same architecture. Lets try it out on a range of circumstances." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we pass it a full CX circuit without `LexiRouteRoutingMethod`, we should find that `MappingManager` throws an error, as none of the passed methods can route for the given circuit." ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Error reached!\n" ] } ], "source": [ "c = (\n", " Circuit(4)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "place_with_map(c, naive_map)\n", "try:\n", " mapping_manager.route_circuit(c, [cry_rmc])\n", "except RuntimeError:\n", " print(\"Error reached!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, we can add `LexiRouteRoutingMethod` on top:" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "place_with_map(c, naive_map)\n", "mapping_manager.route_circuit(c, [cry_rmc, LexiRouteRoutingMethod(10)])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However as there are no CRy gates our new method is unused. We can add one:" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CRy(0.6, 0, 2)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "mapping_manager.route_circuit(c, [lexi_label, cry_rmc, LexiRouteRoutingMethod(10)])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This time we can see our decomposition! If we reorder the methods though `LexiRouteRoutingMethod` is checked first (and returns True), so our new method is unused. The order is important!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, lets see what happens if the gate is not at the right distance initially." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = (\n", " Circuit(4)\n", " .CRy(0.6, 0, 3)\n", " .CX(0, 1)\n", " .CX(1, 2)\n", " .CX(0, 2)\n", " .CX(0, 3)\n", " .CX(2, 3)\n", " .CX(1, 3)\n", " .CX(0, 1)\n", " .measure_all()\n", ")\n", "mapping_manager.route_circuit(c, [lexi_label, cry_rmc, LexiRouteRoutingMethod(10)])\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Above a SWAP gate is inserted by `LexiRouteRoutingMethod` before anything else." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For anyone interested, a simple extension exercise could be to extend this to additionally work for distance-2 CRx and CRz. Alternatively one could improve on the method itself - this approach always decomposes a CRy at distance-2, but is this a good idea?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Also note that higher performance solutions are coded straight into the TKET c++ codebase. This provides advantages, including that Circuit construction and substitution is unnecessary (as with python) as the circuit can be directly modified, however the ability to produce prototypes at the python level is very helpful. If you have a great python implementation but are finding some runtime bottlenecks, why not try implementing it straight into TKET (the code is open source at https://github.com/Quantinuum/tket)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Besides the `LexiRouteRoutingMethod()` and the `LexiLabellingMethod()` there are other routing methods in pytket, such as the `AASRouteRoutingMethod()` and the corresponding `AASLabellingMethod()`, which are used to route phase-polynomial boxes using architecture-aware synthesis. Usually circuits contain non-phase-polynomial operations as well, so it is a good idea to combine them with the `LexiRouteRoutingMethod()`, as in the following example:" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [], "source": [ "from pytket.mapping import AASRouteRoutingMethod, AASLabellingMethod\n", "from pytket.circuit import PhasePolyBox, Qubit\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "c = Circuit(3, 3)\n", "n_qb = 3\n", "qubit_indices = {Qubit(0): 0, Qubit(1): 1, Qubit(2): 2}\n", "phase_polynomial = {(True, False, True): 0.333, (False, False, True): 0.05}\n", "linear_transformation = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\n", "p_box = PhasePolyBox(n_qb, qubit_indices, phase_polynomial, linear_transformation)\n", "c.add_phasepolybox(p_box, [0, 1, 2])\n", "c.CX(0, 1).CX(0, 2).CX(1, 2)\n", "display.render_circuit_jupyter(c)\n", "nodes = [Node(\"test\", 0), Node(\"test\", 1), Node(\"test\", 2)]\n", "arch = Architecture([[nodes[0], nodes[1]], [nodes[1], nodes[2]]])\n", "mm = MappingManager(arch)\n", "mm.route_circuit(\n", " c,\n", " [\n", " AASRouteRoutingMethod(1),\n", " LexiLabellingMethod(),\n", " LexiRouteRoutingMethod(),\n", " AASLabellingMethod(),\n", " ],\n", ")\n", "display.render_circuit_jupyter(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this case the order of the methods is not very relevant, because in each step of the routing only one of the methods is suitable. In the first part of the circuit the mapping is done without inserting swaps by the AAS method; in the second part one swap gate is added to the circuit." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.2" } }, "nbformat": 4, "nbformat_minor": 2 }