Token swapper permutation synthesis plugin

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -14,13 +14,16 @@
 """Synthesize higher-level objects."""
 
 from typing import Optional
+import rustworkx as rx
 
+from qiskit.circuit import QuantumCircuit
 from qiskit.converters import circuit_to_dag
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.coupling import CouplingMap
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.exceptions import TranspilerError, CouplingError
+from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
 
 from qiskit.synthesis.clifford import (
     synth_clifford_full,
@@ -404,3 +407,66 @@ def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **
         """Run synthesis for the given Permutation."""
         decomposition = synth_permutation_acg(high_level_object.pattern)
         return decomposition
+
+
+class TokenSwapperSynthesisPermutation(HighLevelSynthesisPlugin):
+    """The permutation synthesis plugin based on the token swapper algorithm.
+
+    This plugin name is :``permutation.token_swapper`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    In more detail, this plugin is used to synthesize objects of type `PermutationGate`.
+    When synthesis succeeds, the plugin outputs a quantum circuit consisting only of swap
+    gates. When synthesis does not succeed, the plugin outputs `None`.
+
+    If either `coupling_map` or `qubits` is None, then the synthesized circuit
+    is not required to adhere to connectivity constraints, as is the case
+    when the synthesis is done before layout/routing.
+
+    On the other hand, if both `coupling_map` and `qubits` are specified, the synthesized
+    circuit is supposed to adhere to connectivity constraint. At the moment, the plugin
+    only works when `qubits` represents a connected subset of `coupling_map` (if this is
+    not the case, the plugin outputs `None`).
+
+    The plugin supports the following plugin-specific options:
+
+    * trials: The number of trials for the token swapper to perform the mapping. The
+      circuit with the smallest number of SWAPs is returned.
+
+    For more details on the token swapper algorithm, see to the paper:
+    `arXiv:1809.03452 <https://arxiv.org/abs/1809.03452>`__.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Permutation."""
+
+        pattern = high_level_object.pattern
+        trials = options.get("trials", 5)
+
+        pattern_as_dict = {j: i for i, j in enumerate(pattern)}
+
+        if coupling_map is None or qubits is None:
+            # The abstract synthesis uses a fully connected coupling map, allowing
+            # arbitrary connections between qubits
+            used_coupling_map = CouplingMap.from_full(len(pattern))
+        else:
+            # The concrete synthesis uses the coupling map restricted to the set of
+            # qubits over which the permutation gate is defined. Currently, we require
+            # this set to be connected (otherwise, replacing the node in the DAGCircuit
+            # that defines this PermutationGate by the DAG corresponding to the constructed
+            # decomposition becomes problematic); note that the method `reduce` raises an
+            # error if the reduced coupling map is not connected.
+            try:
+                used_coupling_map = coupling_map.reduce(qubits)
+            except CouplingError:
+                return None
+
+        graph = rx.PyGraph()
+        graph.extend_from_edge_list(list(used_coupling_map.get_edges()))
+        swapper = ApproximateTokenSwapper(graph, seed=1)
+        out = list(swapper.map(pattern_as_dict, trials))
+        decomposition = QuantumCircuit(len(graph.node_indices()))
+        for swap in out:
+            decomposition.swap(*swap)
+        return decomposition

setup.py

@@ -138,6 +138,7 @@
             "permutation.kms = qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation",
             "permutation.basic = qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation",
             "permutation.acg = qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation",
+            "permutation.token_swapper = qiskit.transpiler.passes.synthesis.high_level_synthesis:TokenSwapperSynthesisPermutation",
         ],
         "qiskit.transpiler.routing": [
             "basic = qiskit.transpiler.preset_passmanagers.builtin_plugins:BasicSwapPassManager",

test/python/transpiler/test_high_level_synthesis.py

@@ -13,16 +13,20 @@
 """
 Tests the interface for HighLevelSynthesis transpiler pass.
 """
-
-
+import itertools
 import unittest.mock
 
 from qiskit.circuit import QuantumCircuit, Operation
+from qiskit.circuit.library import PermutationGate, LinearFunction
 from qiskit.test import QiskitTestCase
 from qiskit.transpiler import PassManager, TranspilerError, CouplingMap
-from qiskit.transpiler.passes.synthesis.plugin import HighLevelSynthesisPlugin
+from qiskit.transpiler.passes.synthesis.plugin import (
+    HighLevelSynthesisPlugin,
+    HighLevelSynthesisPluginManager,
+)
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HighLevelSynthesis, HLSConfig
 from qiskit.providers.fake_provider.fake_backend_v2 import FakeBackend5QV2
+from qiskit.quantum_info import Operator
 
 
 # In what follows, we create two simple operations OpA and OpB, that potentially mimic
@@ -462,5 +466,156 @@ def test_qubits_get_passed_to_plugins(self):
             pm_use_qubits_true.run(qc)
 
 
+class TestTokenSwapperPermutationPlugin(QiskitTestCase):
+    """Tests for the token swapper plugin for synthesizing permutation gates."""
+
+    def test_token_swapper_in_known_plugin_names(self):
+        """Test that "token_swapper" is an available synthesis plugin for permutation gates."""
+        self.assertIn(
+            "token_swapper", HighLevelSynthesisPluginManager().method_names("permutation")
+        )
+
+    def test_abstract_synthesis(self):
+        """Test abstract synthesis of a permutation gate (either the coupling map or the set
+        of qubits over which the permutation is defined is not specified).
+        """
+
+        # Permutation gate
+        # 4->0, 6->1, 3->2, 7->3, 1->4, 2->5, 0->6, 5->7
+        perm = PermutationGate([4, 6, 3, 7, 1, 2, 0, 5])
+
+        # Circuit with permutation gate
+        qc = QuantumCircuit(8)
+        qc.append(perm, range(8))
+
+        # Synthesize circuit using the token swapper plugin
+        synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])
+        qc_transpiled = PassManager(HighLevelSynthesis(synthesis_config)).run(qc)
+
+        # Construct the expected quantum circuit
+        # From the description below we can see that
+        #   0->6, 1->4, 2->5, 3->2, 4->0, 5->2->3->7, 6->0->4->1, 7->3
+        qc_expected = QuantumCircuit(8)
+        qc_expected.swap(2, 5)
+        qc_expected.swap(0, 6)
+        qc_expected.swap(2, 3)
+        qc_expected.swap(0, 4)
+        qc_expected.swap(1, 4)
+        qc_expected.swap(3, 7)
+
+        self.assertEqual(qc_transpiled, qc_expected)
+
+    def test_concrete_synthesis(self):
+        """Test concrete synthesis of a permutation gate (we have both the coupling map and the
+        set of qubits over which the permutation gate is defined; moreover, the coupling map may
+        have more qubits than the permutation gate).
+        """
+
+        # Permutation gate
+        perm = PermutationGate([0, 1, 4, 3, 2])
+
+        # Circuit with permutation gate
+        qc = QuantumCircuit(8)
+        qc.append(perm, [3, 4, 5, 6, 7])
+
+        coupling_map = CouplingMap.from_ring(8)
+
+        synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])
+        qc_transpiled = PassManager(
+            HighLevelSynthesis(
+                synthesis_config, coupling_map=coupling_map, target=None, use_qubit_indices=True
+            )
+        ).run(qc)
+
+        qc_expected = QuantumCircuit(8)
+        qc_expected.swap(6, 7)
+        qc_expected.swap(5, 6)
+        qc_expected.swap(6, 7)
+        self.assertEqual(qc_transpiled, qc_expected)
+
+    def test_concrete_synthesis_over_disconnected_qubits(self):
+        """Test concrete synthesis of a permutation gate over a disconnected set of qubits.
+        In this case the plugin should return `None` and `HighLevelSynthesis`
+        should not change the original circuit.
+        """
+
+        # Permutation gate
+        perm = PermutationGate([4, 3, 2, 1, 0])
+
+        # Circuit with permutation gate
+        qc = QuantumCircuit(10)
+        qc.append(perm, [0, 2, 4, 6, 8])
+
+        coupling_map = CouplingMap.from_ring(10)
+
+        synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])
+        qc_transpiled = PassManager(
+            HighLevelSynthesis(
+                synthesis_config, coupling_map=coupling_map, target=None, use_qubit_indices=True
+            )
+        ).run(qc)
+        self.assertEqual(qc_transpiled, qc)
+
+    def test_abstract_synthesis_all_permutations(self):
+        """Test abstract synthesis of permutation gates, varying permutation gate patterns."""
+
+        edges = [(0, 1), (1, 0), (1, 2), (2, 1), (1, 3), (3, 1), (3, 4), (4, 3)]
+
+        coupling_map = CouplingMap()
+        for i in range(5):
+            coupling_map.add_physical_qubit(i)
+        for edge in edges:
+            coupling_map.add_edge(*edge)
+
+        synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])
+        pm = PassManager(
+            HighLevelSynthesis(
+                synthesis_config, coupling_map=coupling_map, target=None, use_qubit_indices=False
+            )
+        )
+
+        for pattern in itertools.permutations(range(4)):
+            qc = QuantumCircuit(5)
+            qc.append(PermutationGate(pattern), [2, 0, 3, 1])
+            self.assertIn("permutation", qc.count_ops())
+
+            qc_transpiled = pm.run(qc)
+            self.assertNotIn("permutation", qc_transpiled.count_ops())
+
+            self.assertEqual(Operator(qc), Operator(qc_transpiled))
+
+    def test_concrete_synthesis_all_permutations(self):
+        """Test concrete synthesis of permutation gates, varying permutation gate patterns."""
+
+        edges = [(0, 1), (1, 0), (1, 2), (2, 1), (1, 3), (3, 1), (3, 4), (4, 3)]
+
+        coupling_map = CouplingMap()
+        for i in range(5):
+            coupling_map.add_physical_qubit(i)
+        for edge in edges:
+            coupling_map.add_edge(*edge)
+
+        synthesis_config = HLSConfig(permutation=[("token_swapper", {"trials": 10})])
+        pm = PassManager(
+            HighLevelSynthesis(
+                synthesis_config, coupling_map=coupling_map, target=None, use_qubit_indices=True
+            )
+        )
+
+        for pattern in itertools.permutations(range(4)):
+
+            qc = QuantumCircuit(5)
+            qc.append(PermutationGate(pattern), [2, 0, 3, 1])
+            self.assertIn("permutation", qc.count_ops())
+
+            qc_transpiled = pm.run(qc)
+            self.assertNotIn("permutation", qc_transpiled.count_ops())
+            self.assertEqual(Operator(qc), Operator(qc_transpiled))
+
+            for inst in qc_transpiled:
+                qubits = tuple([q.index for q in inst.qubits])
+                self.assertIn(qubits, edges)
+
+
 if __name__ == "__main__":
     unittest.main()